libunwind/src/AddressSpace.hpp

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