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