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