gcc/unwind-dw2-fde-glibc.c

   1 /* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2009 Free Software Foundation, Inc.
   2    Contributed by Jakub Jelinek <jakub@redhat.com>.
   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 PT_GNU_EH_FRAME ELF
  26    segment and dl_iterate_phdr to avoid register/deregister calls at
  27    DSO load/unload.  */
  28
  29 #ifndef _GNU_SOURCE
  30 #define _GNU_SOURCE 1
  31 #endif
  32
  33 #include "tconfig.h"
  34 #include "tsystem.h"
  35 #ifndef inhibit_libc
  36 #include <link.h>
  37 #endif
  38 #include "coretypes.h"
  39 #include "tm.h"
  40 #include "dwarf2.h"
  41 #include "unwind.h"
  42 #define NO_BASE_OF_ENCODED_VALUE
  43 #include "unwind-pe.h"
  44 #include "unwind-dw2-fde.h"
  45 #include "unwind-compat.h"
  46 #include "gthr.h"
  47
  48 #if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
  49     && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) \
  50         || (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2 && defined(DT_CONFIG)))
  51
  52 #ifndef __RELOC_POINTER
  53 # define __RELOC_POINTER(ptr, base) ((ptr) + (base))
  54 #endif
  55
  56 static const fde * _Unwind_Find_registered_FDE (void *pc, struct dwarf_eh_bases *bases);
  57
  58 #define _Unwind_Find_FDE _Unwind_Find_registered_FDE
  59 #include "unwind-dw2-fde.c"
  60 #undef _Unwind_Find_FDE
  61
  62 #ifndef PT_GNU_EH_FRAME
  63 #define PT_GNU_EH_FRAME (PT_LOOS + 0x474e550)
  64 #endif
  65
  66 struct unw_eh_callback_data
  67 {
  68   _Unwind_Ptr pc;
  69   void *tbase;
  70   void *dbase;
  71   void *func;
  72   const fde *ret;
  73   int check_cache;
  74 };
  75
  76 struct unw_eh_frame_hdr
  77 {
  78   unsigned char version;
  79   unsigned char eh_frame_ptr_enc;
  80   unsigned char fde_count_enc;
  81   unsigned char table_enc;
  82 };
  83
  84 #define FRAME_HDR_CACHE_SIZE 8
  85
  86 static struct frame_hdr_cache_element
  87 {
  88   _Unwind_Ptr pc_low;
  89   _Unwind_Ptr pc_high;
  90   _Unwind_Ptr load_base;
  91   const ElfW(Phdr) *p_eh_frame_hdr;
  92   const ElfW(Phdr) *p_dynamic;
  93   struct frame_hdr_cache_element *link;
  94 } frame_hdr_cache[FRAME_HDR_CACHE_SIZE];
  95
  96 static struct frame_hdr_cache_element *frame_hdr_cache_head;
  97
  98 /* Like base_of_encoded_value, but take the base from a struct
  99    unw_eh_callback_data instead of an _Unwind_Context.  */
 100
 101 static _Unwind_Ptr
 102 base_from_cb_data (unsigned char encoding, struct unw_eh_callback_data *data)
 103 {
 104   if (encoding == DW_EH_PE_omit)
 105     return 0;
 106
 107   switch (encoding & 0x70)
 108     {
 109     case DW_EH_PE_absptr:
 110     case DW_EH_PE_pcrel:
 111     case DW_EH_PE_aligned:
 112       return 0;
 113
 114     case DW_EH_PE_textrel:
 115       return (_Unwind_Ptr) data->tbase;
 116     case DW_EH_PE_datarel:
 117       return (_Unwind_Ptr) data->dbase;
 118     default:
 119       gcc_unreachable ();
 120     }
 121 }
 122
 123 static int
 124 _Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr)
 125 {
 126   struct unw_eh_callback_data *data = (struct unw_eh_callback_data *) ptr;
 127   const ElfW(Phdr) *phdr, *p_eh_frame_hdr, *p_dynamic;
 128   long n, match;
 129 #ifdef __FRV_FDPIC__
 130   struct elf32_fdpic_loadaddr load_base;
 131 #else
 132   _Unwind_Ptr load_base;
 133 #endif
 134   const unsigned char *p;
 135   const struct unw_eh_frame_hdr *hdr;
 136   _Unwind_Ptr eh_frame;
 137   struct object ob;
 138   _Unwind_Ptr pc_low = 0, pc_high = 0;
 139
 140   struct ext_dl_phdr_info
 141     {
 142       ElfW(Addr) dlpi_addr;
 143       const char *dlpi_name;
 144       const ElfW(Phdr) *dlpi_phdr;
 145       ElfW(Half) dlpi_phnum;
 146       unsigned long long int dlpi_adds;
 147       unsigned long long int dlpi_subs;
 148     };
 149
 150   match = 0;
 151   phdr = info->dlpi_phdr;
 152   load_base = info->dlpi_addr;
 153   p_eh_frame_hdr = NULL;
 154   p_dynamic = NULL;
 155
 156   struct frame_hdr_cache_element *prev_cache_entry = NULL,
 157     *last_cache_entry = NULL;
 158
 159   if (data->check_cache && size >= sizeof (struct ext_dl_phdr_info))
 160     {
 161       static unsigned long long adds = -1ULL, subs;
 162       struct ext_dl_phdr_info *einfo = (struct ext_dl_phdr_info *) info;
 163
 164       /* We use a least recently used cache replacement policy.  Also,
 165          the most recently used cache entries are placed at the head
 166          of the search chain.  */
 167
 168       if (einfo->dlpi_adds == adds && einfo->dlpi_subs == subs)
 169         {
 170           /* Find data->pc in shared library cache.
 171              Set load_base, p_eh_frame_hdr and p_dynamic
 172              plus match from the cache and goto
 173              "Read .eh_frame_hdr header." below.  */
 174
 175           struct frame_hdr_cache_element *cache_entry;
 176
 177           for (cache_entry = frame_hdr_cache_head;
 178                cache_entry;
 179                cache_entry = cache_entry->link)
 180             {
 181               if (data->pc >= cache_entry->pc_low
 182                   && data->pc < cache_entry->pc_high)
 183                 {
 184                   load_base = cache_entry->load_base;
 185                   p_eh_frame_hdr = cache_entry->p_eh_frame_hdr;
 186                   p_dynamic = cache_entry->p_dynamic;
 187
 188                   /* And move the entry we're using to the head.  */
 189                   if (cache_entry != frame_hdr_cache_head)
 190                     {
 191                       prev_cache_entry->link = cache_entry->link;
 192                       cache_entry->link = frame_hdr_cache_head;
 193                       frame_hdr_cache_head = cache_entry;
 194                     }
 195                   goto found;
 196                 }
 197
 198               last_cache_entry = cache_entry;
 199               /* Exit early if we found an unused entry.  */
 200               if ((cache_entry->pc_low | cache_entry->pc_high) == 0)
 201                 break;
 202               if (cache_entry->link != NULL)
 203                 prev_cache_entry = cache_entry;
 204             }
 205         }
 206       else
 207         {
 208           adds = einfo->dlpi_adds;
 209           subs = einfo->dlpi_subs;
 210           /* Initialize the cache.  Create a chain of cache entries,
 211              with the final one terminated by a NULL link.  */
 212           int i;
 213           for (i = 0; i < FRAME_HDR_CACHE_SIZE; i++)
 214             {
 215               frame_hdr_cache[i].pc_low = 0;
 216               frame_hdr_cache[i].pc_high = 0;
 217               frame_hdr_cache[i].link = &frame_hdr_cache[i+1];
 218             }
 219           frame_hdr_cache[i-1].link = NULL;
 220           frame_hdr_cache_head = &frame_hdr_cache[0];
 221           data->check_cache = 0;
 222         }
 223     }
 224
 225   /* Make sure struct dl_phdr_info is at least as big as we need.  */
 226   if (size < offsetof (struct dl_phdr_info, dlpi_phnum)
 227              + sizeof (info->dlpi_phnum))
 228     return -1;
 229
 230   /* See if PC falls into one of the loaded segments.  Find the eh_frame
 231      segment at the same time.  */
 232   for (n = info->dlpi_phnum; --n >= 0; phdr++)
 233     {
 234       if (phdr->p_type == PT_LOAD)
 235         {
 236           _Unwind_Ptr vaddr = (_Unwind_Ptr)
 237             __RELOC_POINTER (phdr->p_vaddr, load_base);
 238           if (data->pc >= vaddr && data->pc < vaddr + phdr->p_memsz)
 239             {
 240               match = 1;
 241               pc_low = vaddr;
 242               pc_high =  vaddr + phdr->p_memsz;
 243             }
 244         }
 245       else if (phdr->p_type == PT_GNU_EH_FRAME)
 246         p_eh_frame_hdr = phdr;
 247       else if (phdr->p_type == PT_DYNAMIC)
 248         p_dynamic = phdr;
 249     }
 250
 251   if (!match)
 252     return 0;
 253
 254   if (size >= sizeof (struct ext_dl_phdr_info))
 255     {
 256       /* Move the cache entry we're about to overwrite to the head of
 257          the list.  If either last_cache_entry or prev_cache_entry are
 258          NULL, that cache entry is already at the head.  */
 259       if (last_cache_entry != NULL && prev_cache_entry != NULL)
 260         {
 261           prev_cache_entry->link = last_cache_entry->link;
 262           last_cache_entry->link = frame_hdr_cache_head;
 263           frame_hdr_cache_head = last_cache_entry;
 264         }
 265
 266       frame_hdr_cache_head->load_base = load_base;
 267       frame_hdr_cache_head->p_eh_frame_hdr = p_eh_frame_hdr;
 268       frame_hdr_cache_head->p_dynamic = p_dynamic;
 269       frame_hdr_cache_head->pc_low = pc_low;
 270       frame_hdr_cache_head->pc_high = pc_high;
 271     }
 272
 273  found:
 274
 275   if (!p_eh_frame_hdr)
 276     return 0;
 277
 278   /* Read .eh_frame_hdr header.  */
 279   hdr = (const struct unw_eh_frame_hdr *)
 280     __RELOC_POINTER (p_eh_frame_hdr->p_vaddr, load_base);
 281   if (hdr->version != 1)
 282     return 1;
 283
 284 #ifdef CRT_GET_RFIB_DATA
 285 # ifdef __i386__
 286   data->dbase = NULL;
 287   if (p_dynamic)
 288     {
 289       /* For dynamically linked executables and shared libraries,
 290          DT_PLTGOT is the gp value for that object.  */
 291       ElfW(Dyn) *dyn = (ElfW(Dyn) *)
 292         __RELOC_POINTER (p_dynamic->p_vaddr, load_base);
 293       for (; dyn->d_tag != DT_NULL ; dyn++)
 294         if (dyn->d_tag == DT_PLTGOT)
 295           {
 296             /* On IA-32, _DYNAMIC is writable and GLIBC has relocated it.  */
 297             data->dbase = (void *) dyn->d_un.d_ptr;
 298             break;
 299           }
 300     }
 301 # elif defined __FRV_FDPIC__ && defined __linux__
 302   data->dbase = load_base.got_value;
 303 # else
 304 #  error What is DW_EH_PE_datarel base on this platform?
 305 # endif
 306 #endif
 307
 308   p = read_encoded_value_with_base (hdr->eh_frame_ptr_enc,
 309                                     base_from_cb_data (hdr->eh_frame_ptr_enc,
 310                                                        data),
 311                                     (const unsigned char *) (hdr + 1),
 312                                     &eh_frame);
 313
 314   /* We require here specific table encoding to speed things up.
 315      Also, DW_EH_PE_datarel here means using PT_GNU_EH_FRAME start
 316      as base, not the processor specific DW_EH_PE_datarel.  */
 317   if (hdr->fde_count_enc != DW_EH_PE_omit
 318       && hdr->table_enc == (DW_EH_PE_datarel | DW_EH_PE_sdata4))
 319     {
 320       _Unwind_Ptr fde_count;
 321
 322       p = read_encoded_value_with_base (hdr->fde_count_enc,
 323                                         base_from_cb_data (hdr->fde_count_enc,
 324                                                            data),
 325                                         p, &fde_count);
 326       /* Shouldn't happen.  */
 327       if (fde_count == 0)
 328         return 1;
 329       if ((((_Unwind_Ptr) p) & 3) == 0)
 330         {
 331           struct fde_table {
 332             signed initial_loc __attribute__ ((mode (SI)));
 333             signed fde __attribute__ ((mode (SI)));
 334           };
 335           const struct fde_table *table = (const struct fde_table *) p;
 336           size_t lo, hi, mid;
 337           _Unwind_Ptr data_base = (_Unwind_Ptr) hdr;
 338           fde *f;
 339           unsigned int f_enc, f_enc_size;
 340           _Unwind_Ptr range;
 341
 342           mid = fde_count - 1;
 343           if (data->pc < table[0].initial_loc + data_base)
 344             return 1;
 345           else if (data->pc < table[mid].initial_loc + data_base)
 346             {
 347               lo = 0;
 348               hi = mid;
 349
 350               while (lo < hi)
 351                 {
 352                   mid = (lo + hi) / 2;
 353                   if (data->pc < table[mid].initial_loc + data_base)
 354                     hi = mid;
 355                   else if (data->pc >= table[mid + 1].initial_loc + data_base)
 356                     lo = mid + 1;
 357                   else
 358                     break;
 359                 }
 360
 361               gcc_assert (lo < hi);
 362             }
 363
 364           f = (fde *) (table[mid].fde + data_base);
 365           f_enc = get_fde_encoding (f);
 366           f_enc_size = size_of_encoded_value (f_enc);
 367           read_encoded_value_with_base (f_enc & 0x0f, 0,
 368                                         &f->pc_begin[f_enc_size], &range);
 369           if (data->pc < table[mid].initial_loc + data_base + range)
 370             data->ret = f;
 371           data->func = (void *) (table[mid].initial_loc + data_base);
 372           return 1;
 373         }
 374     }
 375
 376   /* We have no sorted search table, so need to go the slow way.
 377      As soon as GLIBC will provide API so to notify that a library has been
 378      removed, we could cache this (and thus use search_object).  */
 379   ob.pc_begin = NULL;
 380   ob.tbase = data->tbase;
 381   ob.dbase = data->dbase;
 382   ob.u.single = (fde *) eh_frame;
 383   ob.s.i = 0;
 384   ob.s.b.mixed_encoding = 1;  /* Need to assume worst case.  */
 385   data->ret = linear_search_fdes (&ob, (fde *) eh_frame, (void *) data->pc);
 386   if (data->ret != NULL)
 387     {
 388       _Unwind_Ptr func;
 389       unsigned int encoding = get_fde_encoding (data->ret);
 390
 391       read_encoded_value_with_base (encoding,
 392                                     base_from_cb_data (encoding, data),
 393                                     data->ret->pc_begin, &func);
 394       data->func = (void *) func;
 395     }
 396   return 1;
 397 }
 398
 399 const fde *
 400 _Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases)
 401 {
 402   struct unw_eh_callback_data data;
 403   const fde *ret;
 404
 405   ret = _Unwind_Find_registered_FDE (pc, bases);
 406   if (ret != NULL)
 407     return ret;
 408
 409   data.pc = (_Unwind_Ptr) pc;
 410   data.tbase = NULL;
 411   data.dbase = NULL;
 412   data.func = NULL;
 413   data.ret = NULL;
 414   data.check_cache = 1;
 415
 416   if (dl_iterate_phdr (_Unwind_IteratePhdrCallback, &data) < 0)
 417     return NULL;
 418
 419   if (data.ret)
 420     {
 421       bases->tbase = data.tbase;
 422       bases->dbase = data.dbase;
 423       bases->func = data.func;
 424     }
 425   return data.ret;
 426 }
 427
 428 #else
 429 /* Prevent multiple include of header files.  */
 430 #define _Unwind_Find_FDE _Unwind_Find_FDE
 431 #include "unwind-dw2-fde.c"
 432 #endif
 433
 434 #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
 435 alias (_Unwind_Find_FDE);
 436 #endif