sysdeps/generic/unwind-dw2-fde-glibc.c

   1 /* Copyright (C) 2001 Free Software Foundation, Inc.
   2    Contributed by Jakub Jelinek <jakub@redhat.com>.
   3
   4    This file is part of GNU CC.
   5
   6    GNU CC 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 2, or (at your option)
   9    any later version.
  10
  11    GNU CC 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    You should have received a copy of the GNU General Public License
  17    along with GNU CC; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 /* As a special exception, if you link this library with other files,
  22    some of which are compiled with GCC, to produce an executable,
  23    this library does not by itself cause the resulting executable
  24    to be covered by the GNU General Public License.
  25    This exception does not however invalidate any other reasons why
  26    the executable file might be covered by the GNU General Public License.  */
  27
  28 /* Locate the FDE entry for a given address, using PT_GNU_EH_FRAME ELF
  29    segment and dl_iterate_phdr to avoid register/deregister calls at
  30    DSO load/unload.  */
  31
  32 #ifdef _LIBC
  33 # include <shlib-compat.h>
  34 #endif
  35
  36 #if !defined _LIBC || SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2_5)
  37
  38 #include <link.h>
  39 #include <stddef.h>
  40
  41 #define _Unwind_Find_FDE _Unwind_Find_registered_FDE
  42
  43 #include <unwind-dw2-fde.c>
  44
  45 #undef _Unwind_Find_FDE
  46
  47 fde * _Unwind_Find_registered_FDE (void *pc, struct dwarf_eh_bases *bases);
  48
  49 struct unw_eh_callback_data
  50 {
  51   _Unwind_Ptr pc;
  52   void *tbase;
  53   void *dbase;
  54   void *func;
  55   fde *ret;
  56 };
  57
  58 struct unw_eh_frame_hdr
  59 {
  60   unsigned char version;
  61   unsigned char eh_frame_ptr_enc;
  62   unsigned char fde_count_enc;
  63   unsigned char table_enc;
  64 };
  65
  66 /* Like base_of_encoded_value, but take the base from a struct object
  67    instead of an _Unwind_Context.  */
  68
  69 static _Unwind_Ptr
  70 base_from_cb_data (unsigned char encoding, struct unw_eh_callback_data *data)
  71 {
  72   if (encoding == DW_EH_PE_omit)
  73     return 0;
  74
  75   switch (encoding & 0x70)
  76     {
  77     case DW_EH_PE_absptr:
  78     case DW_EH_PE_pcrel:
  79     case DW_EH_PE_aligned:
  80       return 0;
  81
  82     case DW_EH_PE_textrel:
  83       return (_Unwind_Ptr) data->tbase;
  84     case DW_EH_PE_datarel:
  85       return (_Unwind_Ptr) data->dbase;
  86     }
  87   abort ();
  88 }
  89
  90 static int
  91 _Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr)
  92 {
  93   struct unw_eh_callback_data *data = (struct unw_eh_callback_data *) ptr;
  94   const ElfW(Phdr) *phdr, *p_eh_frame_hdr, *p_dynamic;
  95   long n, match;
  96   _Unwind_Ptr load_base;
  97   const unsigned char *p;
  98   const struct unw_eh_frame_hdr *hdr;
  99   _Unwind_Ptr eh_frame;
 100   struct object ob;
 101
 102   /* Make sure struct dl_phdr_info is at least as big as we need.  */
 103   if (size < offsetof (struct dl_phdr_info, dlpi_phnum)
 104              + sizeof (info->dlpi_phnum))
 105     return -1;
 106
 107   match = 0;
 108   phdr = info->dlpi_phdr;
 109   load_base = info->dlpi_addr;
 110   p_eh_frame_hdr = NULL;
 111   p_dynamic = NULL;
 112
 113   /* See if PC falls into one of the loaded segments.  Find the eh_frame
 114      segment at the same time.  */
 115   for (n = info->dlpi_phnum; --n >= 0; phdr++)
 116     {
 117       if (phdr->p_type == PT_LOAD)
 118         {
 119           _Unwind_Ptr vaddr = phdr->p_vaddr + load_base;
 120           if (data->pc >= vaddr && data->pc < vaddr + phdr->p_memsz)
 121             match = 1;
 122         }
 123       else if (phdr->p_type == PT_GNU_EH_FRAME)
 124         p_eh_frame_hdr = phdr;
 125       else if (phdr->p_type == PT_DYNAMIC)
 126         p_dynamic = phdr;
 127     }
 128   if (!match || !p_eh_frame_hdr)
 129     return 0;
 130
 131   /* Read .eh_frame_hdr header.  */
 132   hdr = (const struct unw_eh_frame_hdr *)
 133         (p_eh_frame_hdr->p_vaddr + load_base);
 134   if (hdr->version != 1)
 135     return 1;
 136
 137 #ifdef CRT_GET_RFIB_DATA
 138 # ifdef __i386__
 139   data->dbase = NULL;
 140   if (p_dynamic)
 141     {
 142       /* For dynamicly linked executables and shared libraries,
 143          DT_PLTGOT is the gp value for that object.  */
 144       ElfW(Dyn) *dyn = (ElfW(Dyn) *)(p_dynamic->p_vaddr + load_base);
 145       for (; dyn->d_tag != DT_NULL ; dyn++)
 146         if (dyn->d_tag == DT_PLTGOT)
 147           {
 148             /* On IA-32, _DYNAMIC is writable and GLIBC has relocated it.  */
 149             data->dbase = (void *) dyn->d_un.d_ptr;
 150             break;
 151           }
 152     }
 153 # else
 154 #  error What is DW_EH_PE_datarel base on this platform?
 155 # endif
 156 #endif
 157 #ifdef CRT_GET_RFIB_TEXT
 158 # error What is DW_EH_PE_textrel base on this platform?
 159 #endif
 160
 161   p = read_encoded_value_with_base (hdr->eh_frame_ptr_enc,
 162                                     base_from_cb_data (hdr->eh_frame_ptr_enc,
 163                                                        data),
 164                                     (const unsigned char *) (hdr + 1),
 165                                     &eh_frame);
 166
 167   /* We require here specific table encoding to speed things up.
 168      Also, DW_EH_PE_datarel here means using PT_GNU_EH_FRAME start
 169      as base, not the processor specific DW_EH_PE_datarel.  */
 170   if (hdr->fde_count_enc != DW_EH_PE_omit
 171       && hdr->table_enc == (DW_EH_PE_datarel | DW_EH_PE_sdata4))
 172     {
 173       _Unwind_Ptr fde_count;
 174
 175       p = read_encoded_value_with_base (hdr->fde_count_enc,
 176                                         base_from_cb_data (hdr->fde_count_enc,
 177                                                            data),
 178                                         p, &fde_count);
 179       /* Shouldn't happen.  */
 180       if (fde_count == 0)
 181         return 1;
 182       if ((((_Unwind_Ptr) p) & 3) == 0)
 183         {
 184           struct fde_table {
 185             signed initial_loc __attribute__ ((mode (SI)));
 186             signed fde __attribute__ ((mode (SI)));
 187           };
 188           const struct fde_table *table = (const struct fde_table *) p;
 189           size_t lo, hi, mid;
 190           _Unwind_Ptr data_base = (_Unwind_Ptr) hdr;
 191           fde *f;
 192           unsigned int f_enc, f_enc_size;
 193           _Unwind_Ptr range;
 194
 195           mid = fde_count - 1;
 196           if (data->pc < table[0].initial_loc + data_base)
 197             return 1;
 198           else if (data->pc < table[mid].initial_loc + data_base)
 199             {
 200               lo = 0;
 201               hi = mid;
 202
 203               while (lo < hi)
 204                 {
 205                   mid = (lo + hi) / 2;
 206                   if (data->pc < table[mid].initial_loc + data_base)
 207                     hi = mid;
 208                   else if (data->pc >= table[mid + 1].initial_loc + data_base)
 209                     lo = mid + 1;
 210                   else
 211                     break;
 212                 }
 213
 214               if (lo >= hi)
 215                 __gxx_abort ();
 216             }
 217
 218           f = (fde *) (table[mid].fde + data_base);
 219           f_enc = get_fde_encoding (f);
 220           f_enc_size = size_of_encoded_value (f_enc);
 221           read_encoded_value_with_base (f_enc & 0x0f, 0,
 222                                         &f->pc_begin[f_enc_size], &range);
 223           if (data->pc < table[mid].initial_loc + data_base + range)
 224             data->ret = f;
 225           data->func = (void *) (table[mid].initial_loc + data_base);
 226           return 1;
 227         }
 228     }
 229
 230   /* We have no sorted search table, so need to go the slow way.
 231      As soon as GLIBC will provide API so to notify that a library has been
 232      removed, we could cache this (and thus use search_object).  */
 233   ob.pc_begin = NULL;
 234   ob.tbase = data->tbase;
 235   ob.dbase = data->dbase;
 236   ob.u.single = (fde *) eh_frame;
 237   ob.s.i = 0;
 238   ob.s.b.mixed_encoding = 1;  /* Need to assume worst case.  */
 239   data->ret = linear_search_fdes (&ob, (fde *) eh_frame, (void *) data->pc);
 240   if (data->ret != NULL)
 241     {
 242       unsigned int encoding = get_fde_encoding (data->ret);
 243       read_encoded_value_with_base (encoding,
 244                                     base_from_cb_data (encoding, data),
 245                                     data->ret->pc_begin,
 246                                     (_Unwind_Ptr *)&data->func);
 247     }
 248   return 1;
 249 }
 250
 251 fde *
 252 _Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases)
 253 {
 254   struct unw_eh_callback_data data;
 255   fde *ret;
 256
 257   ret = _Unwind_Find_registered_FDE (pc, bases);
 258   if (ret != NULL)
 259     return ret;
 260
 261   data.pc = (_Unwind_Ptr) pc;
 262   data.tbase = NULL;
 263   data.dbase = NULL;
 264   data.func = NULL;
 265   data.ret = NULL;
 266
 267   if (dl_iterate_phdr (_Unwind_IteratePhdrCallback, &data) < 0)
 268     return NULL;
 269
 270   if (data.ret)
 271     {
 272       bases->tbase = data.tbase;
 273       bases->dbase = data.dbase;
 274       bases->func = data.func;
 275     }
 276   return data.ret;
 277 }
 278
 279 #endif