1 //===------------------------- AddressSpace.hpp ---------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 // 8 // Abstracts accessing local vs remote address spaces. 9 // 10 //===----------------------------------------------------------------------===// 11 12 #ifndef __ADDRESSSPACE_HPP__ 13 #define __ADDRESSSPACE_HPP__ 14 15 #include <stdint.h> 16 #include <stdio.h> 17 #include <stdlib.h> 18 #include <string.h> 19 20 #ifndef _LIBUNWIND_USE_DLADDR 21 #if !defined(_LIBUNWIND_IS_BAREMETAL) && !defined(_WIN32) 22 #define _LIBUNWIND_USE_DLADDR 1 23 #else 24 #define _LIBUNWIND_USE_DLADDR 0 25 #endif 26 #endif 27 28 #if _LIBUNWIND_USE_DLADDR 29 #include <dlfcn.h> 30 #if defined(__ELF__) && defined(_LIBUNWIND_LINK_DL_LIB) 31 #pragma comment(lib, "dl") 32 #endif 33 #endif 34 35 #if defined(_LIBUNWIND_ARM_EHABI) 36 struct EHABIIndexEntry { 37 uint32_t functionOffset; 38 uint32_t data; 39 }; 40 #endif 41 42 #include "libunwind.h" 43 #include "config.h" 44 #include "dwarf2.h" 45 #include "EHHeaderParser.hpp" 46 #include "Registers.hpp" 47 48 #ifdef __APPLE__ 49 50 struct dyld_unwind_sections 51 { 52 const struct mach_header* mh; 53 const void* dwarf_section; 54 uintptr_t dwarf_section_length; 55 const void* compact_unwind_section; 56 uintptr_t compact_unwind_section_length; 57 }; 58 59 // In 10.7.0 or later, libSystem.dylib implements this function. 60 extern "C" bool _dyld_find_unwind_sections(void *, dyld_unwind_sections *); 61 62 #elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_LIBUNWIND_IS_BAREMETAL) 63 64 // When statically linked on bare-metal, the symbols for the EH table are looked 65 // up without going through the dynamic loader. 66 67 // The following linker script may be used to produce the necessary sections and symbols. 68 // Unless the --eh-frame-hdr linker option is provided, the section is not generated 69 // and does not take space in the output file. 70 // 71 // .eh_frame : 72 // { 73 // __eh_frame_start = .; 74 // KEEP(*(.eh_frame)) 75 // __eh_frame_end = .; 76 // } 77 // 78 // .eh_frame_hdr : 79 // { 80 // KEEP(*(.eh_frame_hdr)) 81 // } 82 // 83 // __eh_frame_hdr_start = SIZEOF(.eh_frame_hdr) > 0 ? ADDR(.eh_frame_hdr) : 0; 84 // __eh_frame_hdr_end = SIZEOF(.eh_frame_hdr) > 0 ? . : 0; 85 86 extern char __eh_frame_start; 87 extern char __eh_frame_end; 88 89 #if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX) 90 extern char __eh_frame_hdr_start; 91 extern char __eh_frame_hdr_end; 92 #endif 93 94 #elif defined(_LIBUNWIND_ARM_EHABI) && defined(_LIBUNWIND_IS_BAREMETAL) 95 96 // When statically linked on bare-metal, the symbols for the EH table are looked 97 // up without going through the dynamic loader. 98 extern char __exidx_start; 99 extern char __exidx_end; 100 101 #elif defined(_LIBUNWIND_ARM_EHABI) || defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 102 103 // ELF-based systems may use dl_iterate_phdr() to access sections 104 // containing unwinding information. The ElfW() macro for pointer-size 105 // independent ELF header traversal is not provided by <link.h> on some 106 // systems (e.g., FreeBSD). On these systems the data structures are 107 // just called Elf_XXX. Define ElfW() locally. 108 #ifndef _WIN32 109 #include <link.h> 110 #else 111 #include <windows.h> 112 #include <psapi.h> 113 #endif 114 #if !defined(ElfW) 115 #define ElfW(type) Elf_##type 116 #endif 117 118 #endif 119 120 namespace libunwind { 121 122 /// Used by findUnwindSections() to return info about needed sections. 123 struct UnwindInfoSections { 124 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) || defined(_LIBUNWIND_SUPPORT_DWARF_INDEX) || \ 125 defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND) 126 // No dso_base for SEH or ARM EHABI. 127 uintptr_t dso_base; 128 #endif 129 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 130 uintptr_t dwarf_section; 131 uintptr_t dwarf_section_length; 132 #endif 133 #if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX) 134 uintptr_t dwarf_index_section; 135 uintptr_t dwarf_index_section_length; 136 #endif 137 #if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND) 138 uintptr_t compact_unwind_section; 139 uintptr_t compact_unwind_section_length; 140 #endif 141 #if defined(_LIBUNWIND_ARM_EHABI) 142 uintptr_t arm_section; 143 uintptr_t arm_section_length; 144 #endif 145 }; 146 147 148 /// LocalAddressSpace is used as a template parameter to UnwindCursor when 149 /// unwinding a thread in the same process. The wrappers compile away, 150 /// making local unwinds fast. 151 class _LIBUNWIND_HIDDEN LocalAddressSpace { 152 public: 153 typedef uintptr_t pint_t; 154 typedef intptr_t sint_t; 155 uint8_t get8(pint_t addr) { 156 uint8_t val; 157 memcpy(&val, (void *)addr, sizeof(val)); 158 return val; 159 } 160 uint16_t get16(pint_t addr) { 161 uint16_t val; 162 memcpy(&val, (void *)addr, sizeof(val)); 163 return val; 164 } 165 uint32_t get32(pint_t addr) { 166 uint32_t val; 167 memcpy(&val, (void *)addr, sizeof(val)); 168 return val; 169 } 170 uint64_t get64(pint_t addr) { 171 uint64_t val; 172 memcpy(&val, (void *)addr, sizeof(val)); 173 return val; 174 } 175 double getDouble(pint_t addr) { 176 double val; 177 memcpy(&val, (void *)addr, sizeof(val)); 178 return val; 179 } 180 v128 getVector(pint_t addr) { 181 v128 val; 182 memcpy(&val, (void *)addr, sizeof(val)); 183 return val; 184 } 185 uintptr_t getP(pint_t addr); 186 uint64_t getRegister(pint_t addr); 187 static uint64_t getULEB128(pint_t &addr, pint_t end); 188 static int64_t getSLEB128(pint_t &addr, pint_t end); 189 190 pint_t getEncodedP(pint_t &addr, pint_t end, uint8_t encoding, 191 pint_t datarelBase = 0); 192 bool findFunctionName(pint_t addr, char *buf, size_t bufLen, 193 unw_word_t *offset); 194 bool findUnwindSections(pint_t targetAddr, UnwindInfoSections &info); 195 bool findOtherFDE(pint_t targetAddr, pint_t &fde); 196 197 static LocalAddressSpace sThisAddressSpace; 198 }; 199 200 inline uintptr_t LocalAddressSpace::getP(pint_t addr) { 201 #if __SIZEOF_POINTER__ == 8 202 return get64(addr); 203 #else 204 return get32(addr); 205 #endif 206 } 207 208 inline uint64_t LocalAddressSpace::getRegister(pint_t addr) { 209 #if __SIZEOF_POINTER__ == 8 || defined(__mips64) 210 return get64(addr); 211 #else 212 return get32(addr); 213 #endif 214 } 215 216 /// Read a ULEB128 into a 64-bit word. 217 inline uint64_t LocalAddressSpace::getULEB128(pint_t &addr, pint_t end) { 218 const uint8_t *p = (uint8_t *)addr; 219 const uint8_t *pend = (uint8_t *)end; 220 uint64_t result = 0; 221 int bit = 0; 222 do { 223 uint64_t b; 224 225 if (p == pend) 226 _LIBUNWIND_ABORT("truncated uleb128 expression"); 227 228 b = *p & 0x7f; 229 230 if (bit >= 64 || b << bit >> bit != b) { 231 _LIBUNWIND_ABORT("malformed uleb128 expression"); 232 } else { 233 result |= b << bit; 234 bit += 7; 235 } 236 } while (*p++ >= 0x80); 237 addr = (pint_t) p; 238 return result; 239 } 240 241 /// Read a SLEB128 into a 64-bit word. 242 inline int64_t LocalAddressSpace::getSLEB128(pint_t &addr, pint_t end) { 243 const uint8_t *p = (uint8_t *)addr; 244 const uint8_t *pend = (uint8_t *)end; 245 int64_t result = 0; 246 int bit = 0; 247 uint8_t byte; 248 do { 249 if (p == pend) 250 _LIBUNWIND_ABORT("truncated sleb128 expression"); 251 byte = *p++; 252 result |= (uint64_t)(byte & 0x7f) << bit; 253 bit += 7; 254 } while (byte & 0x80); 255 // sign extend negative numbers 256 if ((byte & 0x40) != 0 && bit < 64) 257 result |= (-1ULL) << bit; 258 addr = (pint_t) p; 259 return result; 260 } 261 262 inline LocalAddressSpace::pint_t 263 LocalAddressSpace::getEncodedP(pint_t &addr, pint_t end, uint8_t encoding, 264 pint_t datarelBase) { 265 pint_t startAddr = addr; 266 const uint8_t *p = (uint8_t *)addr; 267 pint_t result; 268 269 // first get value 270 switch (encoding & 0x0F) { 271 case DW_EH_PE_ptr: 272 result = getP(addr); 273 p += sizeof(pint_t); 274 addr = (pint_t) p; 275 break; 276 case DW_EH_PE_uleb128: 277 result = (pint_t)getULEB128(addr, end); 278 break; 279 case DW_EH_PE_udata2: 280 result = get16(addr); 281 p += 2; 282 addr = (pint_t) p; 283 break; 284 case DW_EH_PE_udata4: 285 result = get32(addr); 286 p += 4; 287 addr = (pint_t) p; 288 break; 289 case DW_EH_PE_udata8: 290 result = (pint_t)get64(addr); 291 p += 8; 292 addr = (pint_t) p; 293 break; 294 case DW_EH_PE_sleb128: 295 result = (pint_t)getSLEB128(addr, end); 296 break; 297 case DW_EH_PE_sdata2: 298 // Sign extend from signed 16-bit value. 299 result = (pint_t)(int16_t)get16(addr); 300 p += 2; 301 addr = (pint_t) p; 302 break; 303 case DW_EH_PE_sdata4: 304 // Sign extend from signed 32-bit value. 305 result = (pint_t)(int32_t)get32(addr); 306 p += 4; 307 addr = (pint_t) p; 308 break; 309 case DW_EH_PE_sdata8: 310 result = (pint_t)get64(addr); 311 p += 8; 312 addr = (pint_t) p; 313 break; 314 default: 315 _LIBUNWIND_ABORT("unknown pointer encoding"); 316 } 317 318 // then add relative offset 319 switch (encoding & 0x70) { 320 case DW_EH_PE_absptr: 321 // do nothing 322 break; 323 case DW_EH_PE_pcrel: 324 result += startAddr; 325 break; 326 case DW_EH_PE_textrel: 327 _LIBUNWIND_ABORT("DW_EH_PE_textrel pointer encoding not supported"); 328 break; 329 case DW_EH_PE_datarel: 330 // DW_EH_PE_datarel is only valid in a few places, so the parameter has a 331 // default value of 0, and we abort in the event that someone calls this 332 // function with a datarelBase of 0 and DW_EH_PE_datarel encoding. 333 if (datarelBase == 0) 334 _LIBUNWIND_ABORT("DW_EH_PE_datarel is invalid with a datarelBase of 0"); 335 result += datarelBase; 336 break; 337 case DW_EH_PE_funcrel: 338 _LIBUNWIND_ABORT("DW_EH_PE_funcrel pointer encoding not supported"); 339 break; 340 case DW_EH_PE_aligned: 341 _LIBUNWIND_ABORT("DW_EH_PE_aligned pointer encoding not supported"); 342 break; 343 default: 344 _LIBUNWIND_ABORT("unknown pointer encoding"); 345 break; 346 } 347 348 if (encoding & DW_EH_PE_indirect) 349 result = getP(result); 350 351 return result; 352 } 353 354 #ifdef __APPLE__ 355 #elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_LIBUNWIND_IS_BAREMETAL) 356 #elif defined(_LIBUNWIND_ARM_EHABI) && defined(_LIBUNWIND_IS_BAREMETAL) 357 #elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_WIN32) 358 #elif defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) && defined(_WIN32) 359 #elif defined(_LIBUNWIND_ARM_EHABI) && defined(__BIONIC__) 360 // Code inside findUnwindSections handles all these cases. 361 // 362 // Although the above ifdef chain is ugly, there doesn't seem to be a cleaner 363 // way to handle it. The generalized boolean expression is: 364 // 365 // A OR (B AND C) OR (D AND C) OR (B AND E) OR (F AND E) OR (D AND G) 366 // 367 // Running it through various boolean expression simplifiers gives expressions 368 // that don't help at all. 369 #elif defined(_LIBUNWIND_ARM_EHABI) || defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 370 371 #if !defined(Elf_Half) 372 typedef ElfW(Half) Elf_Half; 373 #endif 374 #if !defined(Elf_Phdr) 375 typedef ElfW(Phdr) Elf_Phdr; 376 #endif 377 #if !defined(Elf_Addr) 378 typedef ElfW(Addr) Elf_Addr; 379 #endif 380 381 static Elf_Addr calculateImageBase(struct dl_phdr_info *pinfo) { 382 Elf_Addr image_base = pinfo->dlpi_addr; 383 #if defined(__ANDROID__) && __ANDROID_API__ < 18 384 if (image_base == 0) { 385 // Normally, an image base of 0 indicates a non-PIE executable. On 386 // versions of Android prior to API 18, the dynamic linker reported a 387 // dlpi_addr of 0 for PIE executables. Compute the true image base 388 // using the PT_PHDR segment. 389 // See https://github.com/android/ndk/issues/505. 390 for (Elf_Half i = 0; i < pinfo->dlpi_phnum; i++) { 391 const Elf_Phdr *phdr = &pinfo->dlpi_phdr[i]; 392 if (phdr->p_type == PT_PHDR) { 393 image_base = reinterpret_cast<Elf_Addr>(pinfo->dlpi_phdr) - 394 phdr->p_vaddr; 395 break; 396 } 397 } 398 } 399 #endif 400 return image_base; 401 } 402 403 struct _LIBUNWIND_HIDDEN dl_iterate_cb_data { 404 LocalAddressSpace *addressSpace; 405 UnwindInfoSections *sects; 406 uintptr_t targetAddr; 407 }; 408 409 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 410 #if !defined(_LIBUNWIND_SUPPORT_DWARF_INDEX) 411 #error "_LIBUNWIND_SUPPORT_DWARF_UNWIND requires _LIBUNWIND_SUPPORT_DWARF_INDEX on this platform." 412 #endif 413 414 #if defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE) 415 #include "FrameHeaderCache.hpp" 416 417 // There should be just one of these per process. 418 static FrameHeaderCache ProcessFrameHeaderCache; 419 #endif 420 421 static bool checkAddrInSegment(const Elf_Phdr *phdr, size_t image_base, 422 dl_iterate_cb_data *cbdata) { 423 if (phdr->p_type == PT_LOAD) { 424 uintptr_t begin = image_base + phdr->p_vaddr; 425 uintptr_t end = begin + phdr->p_memsz; 426 if (cbdata->targetAddr >= begin && cbdata->targetAddr < end) { 427 cbdata->sects->dso_base = begin; 428 cbdata->sects->dwarf_section_length = phdr->p_memsz; 429 return true; 430 } 431 } 432 return false; 433 } 434 435 static int findUnwindSectionsByPhdr(struct dl_phdr_info *pinfo, 436 size_t pinfo_size, void *data) { 437 auto cbdata = static_cast<dl_iterate_cb_data *>(data); 438 if (pinfo->dlpi_phnum == 0 || cbdata->targetAddr < pinfo->dlpi_addr) 439 return 0; 440 #if defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE) 441 if (ProcessFrameHeaderCache.find(pinfo, pinfo_size, data)) 442 return 1; 443 #endif 444 445 Elf_Addr image_base = calculateImageBase(pinfo); 446 bool found_obj = false; 447 bool found_hdr = false; 448 449 // Third phdr is usually the executable phdr. 450 if (pinfo->dlpi_phnum > 2) 451 found_obj = checkAddrInSegment(&pinfo->dlpi_phdr[2], image_base, cbdata); 452 453 // PT_GNU_EH_FRAME is usually near the end. Iterate backward. We already know 454 // that there is one or more phdrs. 455 for (Elf_Half i = pinfo->dlpi_phnum; i > 0; i--) { 456 const Elf_Phdr *phdr = &pinfo->dlpi_phdr[i - 1]; 457 if (!found_hdr && phdr->p_type == PT_GNU_EH_FRAME) { 458 EHHeaderParser<LocalAddressSpace>::EHHeaderInfo hdrInfo; 459 uintptr_t eh_frame_hdr_start = image_base + phdr->p_vaddr; 460 cbdata->sects->dwarf_index_section = eh_frame_hdr_start; 461 cbdata->sects->dwarf_index_section_length = phdr->p_memsz; 462 found_hdr = EHHeaderParser<LocalAddressSpace>::decodeEHHdr( 463 *cbdata->addressSpace, eh_frame_hdr_start, phdr->p_memsz, 464 hdrInfo); 465 if (found_hdr) 466 cbdata->sects->dwarf_section = hdrInfo.eh_frame_ptr; 467 } else if (!found_obj) { 468 found_obj = checkAddrInSegment(phdr, image_base, cbdata); 469 } 470 if (found_obj && found_hdr) { 471 #if defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE) 472 ProcessFrameHeaderCache.add(cbdata->sects); 473 #endif 474 return 1; 475 } 476 } 477 cbdata->sects->dwarf_section_length = 0; 478 return 0; 479 } 480 481 #else // defined(LIBUNWIND_SUPPORT_DWARF_UNWIND) 482 // Given all the #ifdef's above, the code here is for 483 // defined(LIBUNWIND_ARM_EHABI) 484 485 static int findUnwindSectionsByPhdr(struct dl_phdr_info *pinfo, size_t, 486 void *data) { 487 auto *cbdata = static_cast<dl_iterate_cb_data *>(data); 488 bool found_obj = false; 489 bool found_hdr = false; 490 491 assert(cbdata); 492 assert(cbdata->sects); 493 494 if (cbdata->targetAddr < pinfo->dlpi_addr) 495 return 0; 496 497 Elf_Addr image_base = calculateImageBase(pinfo); 498 499 for (Elf_Half i = 0; i < pinfo->dlpi_phnum; i++) { 500 const Elf_Phdr *phdr = &pinfo->dlpi_phdr[i]; 501 if (phdr->p_type == PT_LOAD) { 502 uintptr_t begin = image_base + phdr->p_vaddr; 503 uintptr_t end = begin + phdr->p_memsz; 504 if (cbdata->targetAddr >= begin && cbdata->targetAddr < end) 505 found_obj = true; 506 } else if (phdr->p_type == PT_ARM_EXIDX) { 507 uintptr_t exidx_start = image_base + phdr->p_vaddr; 508 cbdata->sects->arm_section = exidx_start; 509 cbdata->sects->arm_section_length = phdr->p_memsz; 510 found_hdr = true; 511 } 512 } 513 return found_obj && found_hdr; 514 } 515 #endif // defined(LIBUNWIND_SUPPORT_DWARF_UNWIND) 516 #endif // defined(_LIBUNWIND_ARM_EHABI) || defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 517 518 519 inline bool LocalAddressSpace::findUnwindSections(pint_t targetAddr, 520 UnwindInfoSections &info) { 521 #ifdef __APPLE__ 522 dyld_unwind_sections dyldInfo; 523 if (_dyld_find_unwind_sections((void *)targetAddr, &dyldInfo)) { 524 info.dso_base = (uintptr_t)dyldInfo.mh; 525 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 526 info.dwarf_section = (uintptr_t)dyldInfo.dwarf_section; 527 info.dwarf_section_length = dyldInfo.dwarf_section_length; 528 #endif 529 info.compact_unwind_section = (uintptr_t)dyldInfo.compact_unwind_section; 530 info.compact_unwind_section_length = dyldInfo.compact_unwind_section_length; 531 return true; 532 } 533 #elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_LIBUNWIND_IS_BAREMETAL) 534 // Bare metal is statically linked, so no need to ask the dynamic loader 535 info.dwarf_section_length = (uintptr_t)(&__eh_frame_end - &__eh_frame_start); 536 info.dwarf_section = (uintptr_t)(&__eh_frame_start); 537 _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: section %p length %p", 538 (void *)info.dwarf_section, (void *)info.dwarf_section_length); 539 #if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX) 540 info.dwarf_index_section = (uintptr_t)(&__eh_frame_hdr_start); 541 info.dwarf_index_section_length = (uintptr_t)(&__eh_frame_hdr_end - &__eh_frame_hdr_start); 542 _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: index section %p length %p", 543 (void *)info.dwarf_index_section, (void *)info.dwarf_index_section_length); 544 #endif 545 if (info.dwarf_section_length) 546 return true; 547 #elif defined(_LIBUNWIND_ARM_EHABI) && defined(_LIBUNWIND_IS_BAREMETAL) 548 // Bare metal is statically linked, so no need to ask the dynamic loader 549 info.arm_section = (uintptr_t)(&__exidx_start); 550 info.arm_section_length = (uintptr_t)(&__exidx_end - &__exidx_start); 551 _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: section %p length %p", 552 (void *)info.arm_section, (void *)info.arm_section_length); 553 if (info.arm_section && info.arm_section_length) 554 return true; 555 #elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_WIN32) 556 HMODULE mods[1024]; 557 HANDLE process = GetCurrentProcess(); 558 DWORD needed; 559 560 if (!EnumProcessModules(process, mods, sizeof(mods), &needed)) { 561 DWORD err = GetLastError(); 562 _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: EnumProcessModules failed, " 563 "returned error %d", (int)err); 564 return false; 565 } 566 567 for (unsigned i = 0; i < (needed / sizeof(HMODULE)); i++) { 568 PIMAGE_DOS_HEADER pidh = (PIMAGE_DOS_HEADER)mods[i]; 569 PIMAGE_NT_HEADERS pinh = (PIMAGE_NT_HEADERS)((BYTE *)pidh + pidh->e_lfanew); 570 PIMAGE_FILE_HEADER pifh = (PIMAGE_FILE_HEADER)&pinh->FileHeader; 571 PIMAGE_SECTION_HEADER pish = IMAGE_FIRST_SECTION(pinh); 572 bool found_obj = false; 573 bool found_hdr = false; 574 575 info.dso_base = (uintptr_t)mods[i]; 576 for (unsigned j = 0; j < pifh->NumberOfSections; j++, pish++) { 577 uintptr_t begin = pish->VirtualAddress + (uintptr_t)mods[i]; 578 uintptr_t end = begin + pish->Misc.VirtualSize; 579 if (!strncmp((const char *)pish->Name, ".text", 580 IMAGE_SIZEOF_SHORT_NAME)) { 581 if (targetAddr >= begin && targetAddr < end) 582 found_obj = true; 583 } else if (!strncmp((const char *)pish->Name, ".eh_frame", 584 IMAGE_SIZEOF_SHORT_NAME)) { 585 info.dwarf_section = begin; 586 info.dwarf_section_length = pish->Misc.VirtualSize; 587 found_hdr = true; 588 } 589 if (found_obj && found_hdr) 590 return true; 591 } 592 } 593 return false; 594 #elif defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) && defined(_WIN32) 595 // Don't even bother, since Windows has functions that do all this stuff 596 // for us. 597 (void)targetAddr; 598 (void)info; 599 return true; 600 #elif defined(_LIBUNWIND_ARM_EHABI) && defined(__BIONIC__) 601 // For ARM EHABI, Bionic didn't implement dl_iterate_phdr until API 21. After 602 // API 21, dl_iterate_phdr exists, but dl_unwind_find_exidx is much faster. 603 int length = 0; 604 info.arm_section = 605 (uintptr_t)dl_unwind_find_exidx((_Unwind_Ptr)targetAddr, &length); 606 info.arm_section_length = (uintptr_t)length * sizeof(EHABIIndexEntry); 607 if (info.arm_section && info.arm_section_length) 608 return true; 609 #elif defined(_LIBUNWIND_ARM_EHABI) || defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 610 dl_iterate_cb_data cb_data = {this, &info, targetAddr}; 611 int found = dl_iterate_phdr(findUnwindSectionsByPhdr, &cb_data); 612 return static_cast<bool>(found); 613 #endif 614 615 return false; 616 } 617 618 619 inline bool LocalAddressSpace::findOtherFDE(pint_t targetAddr, pint_t &fde) { 620 // TO DO: if OS has way to dynamically register FDEs, check that. 621 (void)targetAddr; 622 (void)fde; 623 return false; 624 } 625 626 inline bool LocalAddressSpace::findFunctionName(pint_t addr, char *buf, 627 size_t bufLen, 628 unw_word_t *offset) { 629 #if _LIBUNWIND_USE_DLADDR 630 Dl_info dyldInfo; 631 if (dladdr((void *)addr, &dyldInfo)) { 632 if (dyldInfo.dli_sname != NULL) { 633 snprintf(buf, bufLen, "%s", dyldInfo.dli_sname); 634 *offset = (addr - (pint_t) dyldInfo.dli_saddr); 635 return true; 636 } 637 } 638 #else 639 (void)addr; 640 (void)buf; 641 (void)bufLen; 642 (void)offset; 643 #endif 644 return false; 645 } 646 647 } // namespace libunwind 648 649 #endif // __ADDRESSSPACE_HPP__ 650