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)
42struct EHABIIndexEntry {
43 uint32_t functionOffset;
44 uint32_t data;
45};
46#endif
47
48#if defined(_AIX)
49namespace libunwind {
50char *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
69namespace 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
97extern char __eh_frame_start;
98extern char __eh_frame_end;
99
100#if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
101extern char __eh_frame_hdr_start;
102extern 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.
109extern char __exidx_start;
110extern 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
124namespace libunwind {
125
126/// Used by findUnwindSections() to return info about needed sections.
127struct 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.
159class _LIBUNWIND_HIDDEN LocalAddressSpace {
160public:
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
208inline 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
216inline 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.
225inline 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.
250inline 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
270inline LocalAddressSpace::pint_t
271LocalAddressSpace::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(addr: 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
380struct _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.
391static FrameHeaderCache TheFrameHeaderCache;
392#endif
393
394static 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
408static 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 addressSpace&: *cbdata->addressSpace, ehHdrStart: eh_frame_hdr_start,
418 ehHdrEnd: eh_frame_hdr_start + phdr->p_memsz, ehHdrInfo&: 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
440static 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(phdr: &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
490inline 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, name: "_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 addressSpace&: *this, ehHdrStart: info.dwarf_index_section,
642 ehHdrEnd: info.dwarf_index_section + info.dwarf_index_section_length,
643 ehHdrInfo&: 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 = {.addressSpace: this, .sects: &info, .targetAddr: targetAddr};
654 int found = dl_iterate_phdr(callback: findUnwindSectionsByPhdr, data: &cb_data);
655 return static_cast<bool>(found);
656#endif
657
658 return false;
659}
660
661inline 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
668inline 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(address: (void *)addr, info: &dyldInfo)) {
674 if (dyldInfo.dli_sname != NULL) {
675 snprintf(s: buf, maxlen: bufLen, format: "%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__
699

source code of libunwind/src/AddressSpace.hpp