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;
get8(pint_t addr)159 uint8_t get8(pint_t addr) {
160 uint8_t val;
161 memcpy(&val, (void *)addr, sizeof(val));
162 return val;
163 }
get16(pint_t addr)164 uint16_t get16(pint_t addr) {
165 uint16_t val;
166 memcpy(&val, (void *)addr, sizeof(val));
167 return val;
168 }
get32(pint_t addr)169 uint32_t get32(pint_t addr) {
170 uint32_t val;
171 memcpy(&val, (void *)addr, sizeof(val));
172 return val;
173 }
get64(pint_t addr)174 uint64_t get64(pint_t addr) {
175 uint64_t val;
176 memcpy(&val, (void *)addr, sizeof(val));
177 return val;
178 }
getDouble(pint_t addr)179 double getDouble(pint_t addr) {
180 double val;
181 memcpy(&val, (void *)addr, sizeof(val));
182 return val;
183 }
getVector(pint_t addr)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
getP(pint_t addr)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
getRegister(pint_t addr)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.
getULEB128(pint_t & addr,pint_t end)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.
getSLEB128(pint_t & addr,pint_t end)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
getEncodedP(pint_t & addr,pint_t end,uint8_t encoding,pint_t datarelBase)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
calculateImageBase(struct dl_phdr_info * pinfo)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
checkAddrInSegment(const Elf_Phdr * phdr,size_t image_base,dl_iterate_cb_data * cbdata)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
checkForUnwindInfoSegment(const Elf_Phdr * phdr,size_t image_base,dl_iterate_cb_data * cbdata)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
findUnwindSectionsByPhdr(struct dl_phdr_info * pinfo,size_t pinfo_size,void * data)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
findUnwindSections(pint_t targetAddr,UnwindInfoSections & info)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
findOtherFDE(pint_t targetAddr,pint_t & fde)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
findFunctionName(pint_t addr,char * buf,size_t bufLen,unw_word_t * offset)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