OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [unwind-dw2-fde-darwin.c] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Copyright (C) 2001, 2002, 2003, 2005, 2009, 2010
2
   Free Software Foundation, Inc.
3
 
4
   This file is part of GCC.
5
 
6
   GCC is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3, or (at your option)
9
   any later version.
10
 
11
   GCC is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   Under Section 7 of GPL version 3, you are granted additional
17
   permissions described in the GCC Runtime Library Exception, version
18
   3.1, as published by the Free Software Foundation.
19
 
20
   You should have received a copy of the GNU General Public License and
21
   a copy of the GCC Runtime Library Exception along with this program;
22
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23
   <http://www.gnu.org/licenses/>.  */
24
 
25
/* Locate the FDE entry for a given address, using Darwin's keymgr support.  */
26
 
27
#include "tconfig.h"
28
#include "tsystem.h"
29
#include <string.h>
30
#include <stdlib.h>
31
#include "dwarf2.h"
32
#include "unwind.h"
33
#define NO_BASE_OF_ENCODED_VALUE
34
#define DWARF2_OBJECT_END_PTR_EXTENSION
35
#include "unwind-pe.h"
36
#include "unwind-dw2-fde.h"
37
/* Carefully don't include gthr.h.  */
38
 
39
typedef int __gthread_mutex_t;
40
#define __gthread_mutex_lock(x)  (void)(x)
41
#define __gthread_mutex_unlock(x) (void)(x)
42
 
43
static const fde * _Unwind_Find_registered_FDE (void *pc,
44
                                                struct dwarf_eh_bases *bases);
45
 
46
#define _Unwind_Find_FDE _Unwind_Find_registered_FDE
47
#include "unwind-dw2-fde.c"
48
#undef _Unwind_Find_FDE
49
 
50
/* KeyMgr stuff.  */
51
#define KEYMGR_GCC3_LIVE_IMAGE_LIST     301     /* loaded images  */
52
#define KEYMGR_GCC3_DW2_OBJ_LIST        302     /* Dwarf2 object list  */
53
 
54
extern void *_keymgr_get_and_lock_processwide_ptr (int);
55
extern void _keymgr_set_and_unlock_processwide_ptr (int, void *);
56
extern void _keymgr_unlock_processwide_ptr (int);
57
 
58
struct mach_header;
59
struct mach_header_64;
60
extern char *getsectdatafromheader (struct mach_header*, const char*,
61
                                    const char *, unsigned long *);
62
extern char *getsectdatafromheader_64 (struct mach_header_64*, const char*,
63
                                       const char *, unsigned long *);
64
 
65
/* This is referenced from KEYMGR_GCC3_DW2_OBJ_LIST.  */
66
struct km_object_info {
67
  struct object *seen_objects;
68
  struct object *unseen_objects;
69
  unsigned spare[2];
70
};
71
 
72
/* Node of KEYMGR_GCC3_LIVE_IMAGE_LIST.  Info about each resident image.  */
73
struct live_images {
74
  unsigned long this_size;                      /* sizeof (live_images)  */
75
  struct mach_header *mh;                       /* the image info  */
76
  unsigned long vm_slide;
77
  void (*destructor)(struct live_images *);     /* destructor for this  */
78
  struct live_images *next;
79
  unsigned int examined_p;
80
  void *fde;
81
  void *object_info;
82
  unsigned long info[2];                        /* Future use.  */
83
};
84
 
85
/* Bits in the examined_p field of struct live_images.  */
86
enum {
87
  EXAMINED_IMAGE_MASK = 1,      /* We've seen this one.  */
88
  ALLOCED_IMAGE_MASK = 2,       /* The FDE entries were allocated by
89
                                   malloc, and must be freed.  This isn't
90
                                   used by newer libgcc versions.  */
91
  IMAGE_IS_TEXT_MASK = 4,       /* This image is in the TEXT segment.  */
92
  DESTRUCTOR_MAY_BE_CALLED_LIVE = 8  /* The destructor may be called on an
93
                                        object that's part of the live
94
                                        image list.  */
95
};
96
 
97
/* Delete any data we allocated on a live_images structure.  Either
98
   IMAGE has already been removed from the
99
   KEYMGR_GCC3_LIVE_IMAGE_LIST and the struct will be deleted
100
   after we return, or that list is locked and we're being called
101
   because this object might be about to be unloaded.  Called by
102
   KeyMgr.  */
103
 
104
static void
105
live_image_destructor (struct live_images *image)
106
{
107
  if (image->object_info)
108
    {
109
      struct km_object_info *the_obj_info;
110
 
111
      the_obj_info =
112
        _keymgr_get_and_lock_processwide_ptr (KEYMGR_GCC3_DW2_OBJ_LIST);
113
      if (the_obj_info)
114
        {
115
          seen_objects = the_obj_info->seen_objects;
116
          unseen_objects = the_obj_info->unseen_objects;
117
 
118
          /* Free any sorted arrays.  */
119
          __deregister_frame_info_bases (image->fde);
120
 
121
          the_obj_info->seen_objects = seen_objects;
122
          the_obj_info->unseen_objects = unseen_objects;
123
        }
124
      _keymgr_set_and_unlock_processwide_ptr (KEYMGR_GCC3_DW2_OBJ_LIST,
125
                                              the_obj_info);
126
 
127
      free (image->object_info);
128
      image->object_info = NULL;
129
      if (image->examined_p & ALLOCED_IMAGE_MASK)
130
        free (image->fde);
131
      image->fde = NULL;
132
    }
133
  image->examined_p = 0;
134
  image->destructor = NULL;
135
}
136
 
137
/* Run through the list of live images.  If we can allocate memory,
138
   give each unseen image a new `struct object'.  Even if we can't,
139
   check whether the PC is inside the FDE of each unseen image.
140
 */
141
 
142
static inline const fde *
143
examine_objects (void *pc, struct dwarf_eh_bases *bases, int dont_alloc)
144
{
145
  const fde *result = NULL;
146
  struct live_images *image;
147
 
148
  image = _keymgr_get_and_lock_processwide_ptr (KEYMGR_GCC3_LIVE_IMAGE_LIST);
149
 
150
  for (; image != NULL; image = image->next)
151
    if ((image->examined_p & EXAMINED_IMAGE_MASK) == 0)
152
      {
153
        char *fde = NULL;
154
        unsigned long sz;
155
 
156
        /* For ppc only check whether or not we have __DATA eh frames.  */
157
#ifdef __ppc__
158
        fde = getsectdatafromheader (image->mh, "__DATA", "__eh_frame", &sz);
159
#endif
160
 
161
        if (fde == NULL)
162
          {
163
#if __LP64__
164
            fde = getsectdatafromheader_64 ((struct mach_header_64 *) image->mh,
165
                                            "__TEXT", "__eh_frame", &sz);
166
#else
167
            fde = getsectdatafromheader (image->mh, "__TEXT",
168
                                         "__eh_frame", &sz);
169
#endif
170
            if (fde != NULL)
171
              image->examined_p |= IMAGE_IS_TEXT_MASK;
172
          }
173
 
174
        /* If .eh_frame is empty, don't register at all.  */
175
        if (fde != NULL && sz > 0)
176
          {
177
            char *real_fde = (fde + image->vm_slide);
178
            struct object *ob = NULL;
179
            struct object panicob;
180
 
181
            if (! dont_alloc)
182
              ob = calloc (1, sizeof (struct object));
183
            dont_alloc |= ob == NULL;
184
            if (dont_alloc)
185
              ob = &panicob;
186
 
187
            ob->pc_begin = (void *)-1;
188
            ob->tbase = 0;
189
            ob->dbase = 0;
190
            ob->u.single = (struct dwarf_fde *)real_fde;
191
            ob->s.i = 0;
192
            ob->s.b.encoding = DW_EH_PE_omit;
193
            ob->fde_end = real_fde + sz;
194
 
195
            image->fde = real_fde;
196
 
197
            result = search_object (ob, pc);
198
 
199
            if (! dont_alloc)
200
              {
201
                struct object **p;
202
 
203
                image->destructor = live_image_destructor;
204
                image->object_info = ob;
205
 
206
                image->examined_p |= (EXAMINED_IMAGE_MASK
207
                                      | DESTRUCTOR_MAY_BE_CALLED_LIVE);
208
 
209
                /* Insert the object into the classified list.  */
210
                for (p = &seen_objects; *p ; p = &(*p)->next)
211
                  if ((*p)->pc_begin < ob->pc_begin)
212
                    break;
213
                ob->next = *p;
214
                *p = ob;
215
              }
216
 
217
            if (result)
218
              {
219
                int encoding;
220
                _Unwind_Ptr func;
221
 
222
                bases->tbase = ob->tbase;
223
                bases->dbase = ob->dbase;
224
 
225
                encoding = ob->s.b.encoding;
226
                if (ob->s.b.mixed_encoding)
227
                  encoding = get_fde_encoding (result);
228
                read_encoded_value_with_base (encoding,
229
                                              base_from_object (encoding, ob),
230
                                              result->pc_begin, &func);
231
                bases->func = (void *) func;
232
                break;
233
              }
234
          }
235
        else
236
          image->examined_p |= EXAMINED_IMAGE_MASK;
237
      }
238
 
239
  _keymgr_unlock_processwide_ptr (KEYMGR_GCC3_LIVE_IMAGE_LIST);
240
 
241
  return result;
242
}
243
 
244
const fde *
245
_Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases)
246
{
247
  struct km_object_info *the_obj_info;
248
  const fde *ret = NULL;
249
 
250
  the_obj_info =
251
    _keymgr_get_and_lock_processwide_ptr (KEYMGR_GCC3_DW2_OBJ_LIST);
252
  if (! the_obj_info)
253
    the_obj_info = calloc (1, sizeof (*the_obj_info));
254
 
255
  if (the_obj_info != NULL)
256
    {
257
      seen_objects = the_obj_info->seen_objects;
258
      unseen_objects = the_obj_info->unseen_objects;
259
 
260
      ret = _Unwind_Find_registered_FDE (pc, bases);
261
    }
262
 
263
  /* OK, didn't find it in the list of FDEs we've seen before,
264
     so go through and look at the new ones.  */
265
  if (ret == NULL)
266
    ret = examine_objects (pc, bases, the_obj_info == NULL);
267
 
268
  if (the_obj_info != NULL)
269
    {
270
      the_obj_info->seen_objects = seen_objects;
271
      the_obj_info->unseen_objects = unseen_objects;
272
    }
273
  _keymgr_set_and_unlock_processwide_ptr (KEYMGR_GCC3_DW2_OBJ_LIST,
274
                                          the_obj_info);
275
  return ret;
276
}
277
 
278
void *
279
_darwin10_Unwind_FindEnclosingFunction (void *pc)
280
{
281
  struct dwarf_eh_bases bases;
282
  const struct dwarf_fde *fde = _Unwind_Find_FDE (pc-1, &bases);
283
  if (fde)
284
    return bases.func;
285
  else
286
    return NULL;
287
}
288
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.