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