gcc/unwind-dw2-fde-darwin.c

   1 /* Copyright (C) 2001, 2002 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, 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, 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 <string.h>
  31 #include <stdlib.h>
  32 #include "dwarf2.h"
  33 #include "unwind.h"
  34 #define NO_BASE_OF_ENCODED_VALUE
  35 #define DWARF2_OBJECT_END_PTR_EXTENSION
  36 #include "unwind-pe.h"
  37 #include "unwind-dw2-fde.h"
  38 /* Carefully don't include gthr.h.  */
  39
  40 typedef int __gthread_mutex_t;
  41 #define __gthread_mutex_lock(x)  (void)(x)
  42 #define __gthread_mutex_unlock(x) (void)(x)
  43
  44 static fde * _Unwind_Find_registered_FDE (void *pc,
  45                                           struct dwarf_eh_bases *bases);
  46
  47 #define _Unwind_Find_FDE _Unwind_Find_registered_FDE
  48 #include "unwind-dw2-fde.c"
  49 #undef _Unwind_Find_FDE
  50
  51 /* KeyMgr stuff.  */
  52 #define KEYMGR_GCC3_LIVE_IMAGE_LIST     301     /* loaded images  */
  53 #define KEYMGR_GCC3_DW2_OBJ_LIST        302     /* Dwarf2 object list  */
  54
  55 extern void *_keymgr_get_and_lock_processwide_ptr (int);
  56 extern void _keymgr_set_and_unlock_processwide_ptr (int, void *);
  57 extern void _keymgr_unlock_processwide_ptr (int);
  58
  59 struct mach_header;
  60 extern char *getsectdatafromheader (struct mach_header*, const char*,
  61                         const char *, unsigned long *);
  62
  63 /* This is referenced from KEYMGR_GCC3_DW2_OBJ_LIST.  */
  64 struct km_object_info {
  65   struct object *seen_objects;
  66   struct object *unseen_objects;
  67   unsigned spare[2];
  68 };
  69
  70 /* Node of KEYMGR_GCC3_LIVE_IMAGE_LIST.  Info about each resident image.  */
  71 struct live_images {
  72   unsigned long this_size;                      /* sizeof (live_images)  */
  73   struct mach_header *mh;                       /* the image info  */
  74   unsigned long vm_slide;
  75   void (*destructor)(struct live_images *);     /* destructor for this  */
  76   struct live_images *next;
  77   unsigned int examined_p;
  78   void *fde;
  79   void *object_info;
  80   unsigned long info[2];                        /* Future use.  */
  81 };
  82
  83 /* Bits in the examined_p field of struct live_images.  */
  84 enum {
  85   EXAMINED_IMAGE_MASK = 1,      /* We've seen this one.  */
  86   ALLOCED_IMAGE_MASK = 2,       /* The FDE entries were allocated by
  87                                    malloc, and must be freed.  This isn't
  88                                    used by newer libgcc versions.  */
  89   IMAGE_IS_TEXT_MASK = 4        /* This image is in the TEXT segment.  */
  90 };
  91 \f
  92 /* Delete any data we allocated on a live_images structure.
  93    IMAGE has already been removed from the KEYMGR_GCC3_LIVE_IMAGE_LIST.
  94    Called by KeyMgr (which will delete the struct after we return.)  */
  95
  96 static void
  97 live_image_destructor (struct live_images *image)
  98 {
  99   if (image->object_info)
 100     {
 101       /* Free any sorted arrays.  */
 102       __deregister_frame_info_bases (image->fde);
 103
 104       free (image->object_info);
 105       image->object_info = NULL;
 106       if (image->examined_p & ALLOCED_IMAGE_MASK)
 107         free (image->fde);
 108     }
 109 }
 110
 111 /* Run through the list of live images.  If we can allocate memory,
 112    give each unseen image a new `struct object'.  Even if we can't,
 113    check whether the PC is inside the FDE of each unseen image.
 114  */
 115
 116 static inline fde *
 117 examine_objects (void *pc, struct dwarf_eh_bases *bases, int dont_alloc)
 118 {
 119   fde *result = NULL;
 120   struct live_images *image;
 121
 122   image = _keymgr_get_and_lock_processwide_ptr (KEYMGR_GCC3_LIVE_IMAGE_LIST);
 123
 124   for (; image != NULL; image = image->next)
 125     if ((image->examined_p & EXAMINED_IMAGE_MASK) == 0)
 126       {
 127         char *fde;
 128         unsigned long sz;
 129
 130         fde = getsectdatafromheader (image->mh, "__DATA", "__eh_frame", &sz);
 131         if (fde == NULL)
 132           {
 133             fde = getsectdatafromheader (image->mh, "__TEXT",
 134                                          "__eh_frame", &sz);
 135             if (fde != NULL)
 136               image->examined_p |= IMAGE_IS_TEXT_MASK;
 137           }
 138
 139         /* If .eh_frame is empty, don't register at all.  */
 140         if (fde != NULL && sz > 0)
 141           {
 142             char *real_fde = (fde + image->vm_slide);
 143             struct object *ob = NULL;
 144             struct object panicob;
 145
 146             if (! dont_alloc)
 147               ob = calloc (1, sizeof (struct object));
 148             dont_alloc |= ob == NULL;
 149             if (dont_alloc)
 150               ob = &panicob;
 151
 152             ob->pc_begin = (void *)-1;
 153             ob->tbase = 0;
 154             ob->dbase = 0;
 155             ob->u.single = (struct dwarf_fde *)real_fde;
 156             ob->s.i = 0;
 157             ob->s.b.encoding = DW_EH_PE_omit;
 158             ob->fde_end = real_fde + sz;
 159
 160             if (! dont_alloc)
 161               {
 162                 ob->next = unseen_objects;
 163                 unseen_objects = ob;
 164
 165                 image->destructor = live_image_destructor;
 166                 image->object_info = ob;
 167
 168                 image->examined_p |= EXAMINED_IMAGE_MASK;
 169               }
 170             image->fde = real_fde;
 171
 172             result = search_object (ob, pc);
 173             if (result)
 174               {
 175                 int encoding;
 176
 177                 bases->tbase = ob->tbase;
 178                 bases->dbase = ob->dbase;
 179
 180                 encoding = ob->s.b.encoding;
 181                 if (ob->s.b.mixed_encoding)
 182                   encoding = get_fde_encoding (result);
 183                 read_encoded_value_with_base (encoding,
 184                                               base_from_object (encoding, ob),
 185                                               result->pc_begin,
 186                                               (_Unwind_Ptr *)&bases->func);
 187                 break;
 188               }
 189           }
 190         else
 191           image->examined_p |= EXAMINED_IMAGE_MASK;
 192       }
 193
 194   _keymgr_unlock_processwide_ptr (KEYMGR_GCC3_LIVE_IMAGE_LIST);
 195
 196   return result;
 197 }
 198
 199 fde *
 200 _Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases)
 201 {
 202   struct km_object_info *the_obj_info;
 203   fde *ret = NULL;
 204
 205   the_obj_info =
 206     _keymgr_get_and_lock_processwide_ptr (KEYMGR_GCC3_DW2_OBJ_LIST);
 207   if (! the_obj_info)
 208     the_obj_info = calloc (1, sizeof (*the_obj_info));
 209
 210   if (the_obj_info != NULL)
 211     {
 212       seen_objects = the_obj_info->seen_objects;
 213       unseen_objects = the_obj_info->unseen_objects;
 214
 215       ret = _Unwind_Find_registered_FDE (pc, bases);
 216     }
 217
 218   /* OK, didn't find it in the list of FDEs we've seen before,
 219      so go through and look at the new ones.  */
 220   if (ret == NULL)
 221     ret = examine_objects (pc, bases, the_obj_info == NULL);
 222
 223   if (the_obj_info != NULL)
 224     {
 225       the_obj_info->seen_objects = seen_objects;
 226       the_obj_info->unseen_objects = unseen_objects;
 227       _keymgr_set_and_unlock_processwide_ptr (KEYMGR_GCC3_DW2_OBJ_LIST,
 228                                               the_obj_info);
 229     }
 230   return ret;
 231 }