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