1 /* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2009, 2010, 2011
2 Free Software Foundation, Inc.
3 Contributed by Jakub Jelinek <jakub@redhat.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
26 /* Locate the FDE entry for a given address, using PT_GNU_EH_FRAME ELF
27 segment and dl_iterate_phdr to avoid register/deregister calls at
36 #if !defined(inhibit_libc) && !defined(__OpenBSD__)
37 #include <elf.h> /* Get DT_CONFIG. */
39 #include "coretypes.h"
41 #include "libgcc_tm.h"
44 #define NO_BASE_OF_ENCODED_VALUE
45 #include "unwind-pe.h"
46 #include "unwind-dw2-fde.h"
47 #include "unwind-compat.h"
50 #if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
51 && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) \
52 || (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2 && defined(DT_CONFIG)))
53 # define USE_PT_GNU_EH_FRAME
56 #if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
57 && defined(__FreeBSD__) && __FreeBSD__ >= 7
59 # define USE_PT_GNU_EH_FRAME
62 #if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
63 && defined(__OpenBSD__)
64 # define ElfW(type) Elf_##type
65 # define USE_PT_GNU_EH_FRAME
68 #if !defined(inhibit_libc) && defined(HAVE_LD_EH_FRAME_HDR) \
69 && defined(TARGET_DL_ITERATE_PHDR) \
70 && defined(__sun__) && defined(__svr4__)
71 # define USE_PT_GNU_EH_FRAME
74 #if defined(USE_PT_GNU_EH_FRAME)
78 #ifndef __RELOC_POINTER
79 # define __RELOC_POINTER(ptr, base) ((ptr) + (base))
82 static const fde * _Unwind_Find_registered_FDE (void *pc, struct dwarf_eh_bases *bases);
84 #define _Unwind_Find_FDE _Unwind_Find_registered_FDE
85 #include "unwind-dw2-fde.c"
86 #undef _Unwind_Find_FDE
88 #ifndef PT_GNU_EH_FRAME
89 #define PT_GNU_EH_FRAME (PT_LOOS + 0x474e550)
92 struct unw_eh_callback_data
102 struct unw_eh_frame_hdr
104 unsigned char version;
105 unsigned char eh_frame_ptr_enc;
106 unsigned char fde_count_enc;
107 unsigned char table_enc;
110 #define FRAME_HDR_CACHE_SIZE 8
112 static struct frame_hdr_cache_element
116 _Unwind_Ptr load_base;
117 const ElfW(Phdr) *p_eh_frame_hdr;
118 const ElfW(Phdr) *p_dynamic;
119 struct frame_hdr_cache_element *link;
120 } frame_hdr_cache[FRAME_HDR_CACHE_SIZE];
122 static struct frame_hdr_cache_element *frame_hdr_cache_head;
124 /* Like base_of_encoded_value, but take the base from a struct
125 unw_eh_callback_data instead of an _Unwind_Context. */
128 base_from_cb_data (unsigned char encoding, struct unw_eh_callback_data *data)
130 if (encoding == DW_EH_PE_omit)
133 switch (encoding & 0x70)
135 case DW_EH_PE_absptr:
137 case DW_EH_PE_aligned:
140 case DW_EH_PE_textrel:
141 return (_Unwind_Ptr) data->tbase;
142 case DW_EH_PE_datarel:
143 return (_Unwind_Ptr) data->dbase;
150 _Unwind_IteratePhdrCallback (struct dl_phdr_info *info, size_t size, void *ptr)
152 struct unw_eh_callback_data *data = (struct unw_eh_callback_data *) ptr;
153 const ElfW(Phdr) *phdr, *p_eh_frame_hdr, *p_dynamic;
156 struct elf32_fdpic_loadaddr load_base;
158 _Unwind_Ptr load_base;
160 const unsigned char *p;
161 const struct unw_eh_frame_hdr *hdr;
162 _Unwind_Ptr eh_frame;
164 _Unwind_Ptr pc_low = 0, pc_high = 0;
166 struct ext_dl_phdr_info
168 ElfW(Addr) dlpi_addr;
169 const char *dlpi_name;
170 const ElfW(Phdr) *dlpi_phdr;
171 ElfW(Half) dlpi_phnum;
172 unsigned long long int dlpi_adds;
173 unsigned long long int dlpi_subs;
177 phdr = info->dlpi_phdr;
178 load_base = info->dlpi_addr;
179 p_eh_frame_hdr = NULL;
182 struct frame_hdr_cache_element *prev_cache_entry = NULL,
183 *last_cache_entry = NULL;
185 if (data->check_cache && size >= sizeof (struct ext_dl_phdr_info))
187 static unsigned long long adds = -1ULL, subs;
188 struct ext_dl_phdr_info *einfo = (struct ext_dl_phdr_info *) info;
190 /* We use a least recently used cache replacement policy. Also,
191 the most recently used cache entries are placed at the head
192 of the search chain. */
194 if (einfo->dlpi_adds == adds && einfo->dlpi_subs == subs)
196 /* Find data->pc in shared library cache.
197 Set load_base, p_eh_frame_hdr and p_dynamic
198 plus match from the cache and goto
199 "Read .eh_frame_hdr header." below. */
201 struct frame_hdr_cache_element *cache_entry;
203 for (cache_entry = frame_hdr_cache_head;
205 cache_entry = cache_entry->link)
207 if (data->pc >= cache_entry->pc_low
208 && data->pc < cache_entry->pc_high)
210 load_base = cache_entry->load_base;
211 p_eh_frame_hdr = cache_entry->p_eh_frame_hdr;
212 p_dynamic = cache_entry->p_dynamic;
214 /* And move the entry we're using to the head. */
215 if (cache_entry != frame_hdr_cache_head)
217 prev_cache_entry->link = cache_entry->link;
218 cache_entry->link = frame_hdr_cache_head;
219 frame_hdr_cache_head = cache_entry;
224 last_cache_entry = cache_entry;
225 /* Exit early if we found an unused entry. */
226 if ((cache_entry->pc_low | cache_entry->pc_high) == 0)
228 if (cache_entry->link != NULL)
229 prev_cache_entry = cache_entry;
234 adds = einfo->dlpi_adds;
235 subs = einfo->dlpi_subs;
236 /* Initialize the cache. Create a chain of cache entries,
237 with the final one terminated by a NULL link. */
239 for (i = 0; i < FRAME_HDR_CACHE_SIZE; i++)
241 frame_hdr_cache[i].pc_low = 0;
242 frame_hdr_cache[i].pc_high = 0;
243 frame_hdr_cache[i].link = &frame_hdr_cache[i+1];
245 frame_hdr_cache[i-1].link = NULL;
246 frame_hdr_cache_head = &frame_hdr_cache[0];
247 data->check_cache = 0;
251 /* Make sure struct dl_phdr_info is at least as big as we need. */
252 if (size < offsetof (struct dl_phdr_info, dlpi_phnum)
253 + sizeof (info->dlpi_phnum))
256 /* See if PC falls into one of the loaded segments. Find the eh_frame
257 segment at the same time. */
258 for (n = info->dlpi_phnum; --n >= 0; phdr++)
260 if (phdr->p_type == PT_LOAD)
262 _Unwind_Ptr vaddr = (_Unwind_Ptr)
263 __RELOC_POINTER (phdr->p_vaddr, load_base);
264 if (data->pc >= vaddr && data->pc < vaddr + phdr->p_memsz)
268 pc_high = vaddr + phdr->p_memsz;
271 else if (phdr->p_type == PT_GNU_EH_FRAME)
272 p_eh_frame_hdr = phdr;
273 #ifdef PT_SUNW_UNWIND
274 /* Sun ld emits PT_SUNW_UNWIND .eh_frame_hdr sections instead of
275 PT_SUNW_EH_FRAME/PT_GNU_EH_FRAME, so accept them as well. */
276 else if (phdr->p_type == PT_SUNW_UNWIND)
277 p_eh_frame_hdr = phdr;
279 else if (phdr->p_type == PT_DYNAMIC)
286 if (size >= sizeof (struct ext_dl_phdr_info))
288 /* Move the cache entry we're about to overwrite to the head of
289 the list. If either last_cache_entry or prev_cache_entry are
290 NULL, that cache entry is already at the head. */
291 if (last_cache_entry != NULL && prev_cache_entry != NULL)
293 prev_cache_entry->link = last_cache_entry->link;
294 last_cache_entry->link = frame_hdr_cache_head;
295 frame_hdr_cache_head = last_cache_entry;
298 frame_hdr_cache_head->load_base = load_base;
299 frame_hdr_cache_head->p_eh_frame_hdr = p_eh_frame_hdr;
300 frame_hdr_cache_head->p_dynamic = p_dynamic;
301 frame_hdr_cache_head->pc_low = pc_low;
302 frame_hdr_cache_head->pc_high = pc_high;
310 /* Read .eh_frame_hdr header. */
311 hdr = (const struct unw_eh_frame_hdr *)
312 __RELOC_POINTER (p_eh_frame_hdr->p_vaddr, load_base);
313 if (hdr->version != 1)
316 #ifdef CRT_GET_RFIB_DATA
321 /* For dynamically linked executables and shared libraries,
322 DT_PLTGOT is the gp value for that object. */
323 ElfW(Dyn) *dyn = (ElfW(Dyn) *)
324 __RELOC_POINTER (p_dynamic->p_vaddr, load_base);
325 for (; dyn->d_tag != DT_NULL ; dyn++)
326 if (dyn->d_tag == DT_PLTGOT)
328 data->dbase = (void *) dyn->d_un.d_ptr;
329 #if defined __linux__
330 /* On IA-32 Linux, _DYNAMIC is writable and GLIBC has
332 #elif defined __sun__ && defined __svr4__
333 /* On Solaris 2/x86, we need to do this ourselves. */
334 data->dbase += load_base;
339 # elif defined __FRV_FDPIC__ && defined __linux__
340 data->dbase = load_base.got_value;
341 # elif defined __x86_64__ && defined __sun__ && defined __svr4__
342 /* While CRT_GET_RFIB_DATA is also defined for 64-bit Solaris 10+/x86, it
343 doesn't apply since it uses DW_EH_PE_pcrel encoding. */
345 # error What is DW_EH_PE_datarel base on this platform?
349 p = read_encoded_value_with_base (hdr->eh_frame_ptr_enc,
350 base_from_cb_data (hdr->eh_frame_ptr_enc,
352 (const unsigned char *) (hdr + 1),
355 /* We require here specific table encoding to speed things up.
356 Also, DW_EH_PE_datarel here means using PT_GNU_EH_FRAME start
357 as base, not the processor specific DW_EH_PE_datarel. */
358 if (hdr->fde_count_enc != DW_EH_PE_omit
359 && hdr->table_enc == (DW_EH_PE_datarel | DW_EH_PE_sdata4))
361 _Unwind_Ptr fde_count;
363 p = read_encoded_value_with_base (hdr->fde_count_enc,
364 base_from_cb_data (hdr->fde_count_enc,
367 /* Shouldn't happen. */
370 if ((((_Unwind_Ptr) p) & 3) == 0)
373 signed initial_loc __attribute__ ((mode (SI)));
374 signed fde __attribute__ ((mode (SI)));
376 const struct fde_table *table = (const struct fde_table *) p;
378 _Unwind_Ptr data_base = (_Unwind_Ptr) hdr;
380 unsigned int f_enc, f_enc_size;
384 if (data->pc < table[0].initial_loc + data_base)
386 else if (data->pc < table[mid].initial_loc + data_base)
394 if (data->pc < table[mid].initial_loc + data_base)
396 else if (data->pc >= table[mid + 1].initial_loc + data_base)
402 gcc_assert (lo < hi);
405 f = (fde *) (table[mid].fde + data_base);
406 f_enc = get_fde_encoding (f);
407 f_enc_size = size_of_encoded_value (f_enc);
408 read_encoded_value_with_base (f_enc & 0x0f, 0,
409 &f->pc_begin[f_enc_size], &range);
410 if (data->pc < table[mid].initial_loc + data_base + range)
412 data->func = (void *) (table[mid].initial_loc + data_base);
417 /* We have no sorted search table, so need to go the slow way.
418 As soon as GLIBC will provide API so to notify that a library has been
419 removed, we could cache this (and thus use search_object). */
421 ob.tbase = data->tbase;
422 ob.dbase = data->dbase;
423 ob.u.single = (fde *) eh_frame;
425 ob.s.b.mixed_encoding = 1; /* Need to assume worst case. */
426 data->ret = linear_search_fdes (&ob, (fde *) eh_frame, (void *) data->pc);
427 if (data->ret != NULL)
430 unsigned int encoding = get_fde_encoding (data->ret);
432 read_encoded_value_with_base (encoding,
433 base_from_cb_data (encoding, data),
434 data->ret->pc_begin, &func);
435 data->func = (void *) func;
441 _Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases)
443 struct unw_eh_callback_data data;
446 ret = _Unwind_Find_registered_FDE (pc, bases);
450 data.pc = (_Unwind_Ptr) pc;
455 data.check_cache = 1;
457 if (dl_iterate_phdr (_Unwind_IteratePhdrCallback, &data) < 0)
462 bases->tbase = data.tbase;
463 bases->dbase = data.dbase;
464 bases->func = data.func;
470 /* Prevent multiple include of header files. */
471 #define _Unwind_Find_FDE _Unwind_Find_FDE
472 #include "unwind-dw2-fde.c"
475 #if defined (USE_GAS_SYMVER) && defined (SHARED) && defined (USE_LIBUNWIND_EXCEPTIONS)
476 alias (_Unwind_Find_FDE);