gcc/unwind-dw2-fde-darwin.c

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