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