gcc/unwind-dw2-fde-darwin.c

   1 /* 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 \f
  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