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 // Implements unw_* functions from <libunwind.h>
9 //
10 //===----------------------------------------------------------------------===//
11
12 #include <libunwind.h>
13
14 #include "config.h"
15 #include "libunwind_ext.h"
16
17 #include <stdlib.h>
18
19 // Define the __has_feature extension for compilers that do not support it so
20 // that we can later check for the presence of ASan in a compiler-neutral way.
21 #if !defined(__has_feature)
22 #define __has_feature(feature) 0
23 #endif
24
25 #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
26 #include <sanitizer/asan_interface.h>
27 #endif
28
29 #if !defined(__USING_SJLJ_EXCEPTIONS__)
30 #include "AddressSpace.hpp"
31 #include "UnwindCursor.hpp"
32
33 using namespace libunwind;
34
35 /// internal object to represent this processes address space
36 LocalAddressSpace LocalAddressSpace::sThisAddressSpace;
37
38 _LIBUNWIND_EXPORT unw_addr_space_t unw_local_addr_space =
39 (unw_addr_space_t)&LocalAddressSpace::sThisAddressSpace;
40
41 /// Create a cursor of a thread in this process given 'context' recorded by
42 /// __unw_getcontext().
__unw_init_local(unw_cursor_t * cursor,unw_context_t * context)43 _LIBUNWIND_HIDDEN int __unw_init_local(unw_cursor_t *cursor,
44 unw_context_t *context) {
45 _LIBUNWIND_TRACE_API("__unw_init_local(cursor=%p, context=%p)",
46 static_cast<void *>(cursor),
47 static_cast<void *>(context));
48 #if defined(__i386__)
49 # define REGISTER_KIND Registers_x86
50 #elif defined(__x86_64__)
51 # define REGISTER_KIND Registers_x86_64
52 #elif defined(__powerpc64__)
53 # define REGISTER_KIND Registers_ppc64
54 #elif defined(__powerpc__)
55 # define REGISTER_KIND Registers_ppc
56 #elif defined(__aarch64__)
57 # define REGISTER_KIND Registers_arm64
58 #elif defined(__arm__)
59 # define REGISTER_KIND Registers_arm
60 #elif defined(__or1k__)
61 # define REGISTER_KIND Registers_or1k
62 #elif defined(__hexagon__)
63 # define REGISTER_KIND Registers_hexagon
64 #elif defined(__mips__) && defined(_ABIO32) && _MIPS_SIM == _ABIO32
65 # define REGISTER_KIND Registers_mips_o32
66 #elif defined(__mips64)
67 # define REGISTER_KIND Registers_mips_newabi
68 #elif defined(__mips__)
69 # warning The MIPS architecture is not supported with this ABI and environment!
70 #elif defined(__sparc__) && defined(__arch64__)
71 #define REGISTER_KIND Registers_sparc64
72 #elif defined(__sparc__)
73 # define REGISTER_KIND Registers_sparc
74 #elif defined(__riscv)
75 # define REGISTER_KIND Registers_riscv
76 #elif defined(__ve__)
77 # define REGISTER_KIND Registers_ve
78 #elif defined(__s390x__)
79 # define REGISTER_KIND Registers_s390x
80 #else
81 # error Architecture not supported
82 #endif
83 // Use "placement new" to allocate UnwindCursor in the cursor buffer.
84 new (reinterpret_cast<UnwindCursor<LocalAddressSpace, REGISTER_KIND> *>(cursor))
85 UnwindCursor<LocalAddressSpace, REGISTER_KIND>(
86 context, LocalAddressSpace::sThisAddressSpace);
87 #undef REGISTER_KIND
88 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
89 co->setInfoBasedOnIPRegister();
90
91 return UNW_ESUCCESS;
92 }
_LIBUNWIND_WEAK_ALIAS(__unw_init_local,unw_init_local)93 _LIBUNWIND_WEAK_ALIAS(__unw_init_local, unw_init_local)
94
95 /// Get value of specified register at cursor position in stack frame.
96 _LIBUNWIND_HIDDEN int __unw_get_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
97 unw_word_t *value) {
98 _LIBUNWIND_TRACE_API("__unw_get_reg(cursor=%p, regNum=%d, &value=%p)",
99 static_cast<void *>(cursor), regNum,
100 static_cast<void *>(value));
101 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
102 if (co->validReg(regNum)) {
103 *value = co->getReg(regNum);
104 return UNW_ESUCCESS;
105 }
106 return UNW_EBADREG;
107 }
_LIBUNWIND_WEAK_ALIAS(__unw_get_reg,unw_get_reg)108 _LIBUNWIND_WEAK_ALIAS(__unw_get_reg, unw_get_reg)
109
110 /// Set value of specified register at cursor position in stack frame.
111 _LIBUNWIND_HIDDEN int __unw_set_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
112 unw_word_t value) {
113 _LIBUNWIND_TRACE_API("__unw_set_reg(cursor=%p, regNum=%d, value=0x%" PRIxPTR
114 ")",
115 static_cast<void *>(cursor), regNum, value);
116 typedef LocalAddressSpace::pint_t pint_t;
117 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
118 if (co->validReg(regNum)) {
119 co->setReg(regNum, (pint_t)value);
120 // specical case altering IP to re-find info (being called by personality
121 // function)
122 if (regNum == UNW_REG_IP) {
123 unw_proc_info_t info;
124 // First, get the FDE for the old location and then update it.
125 co->getInfo(&info);
126 co->setInfoBasedOnIPRegister(false);
127 // If the original call expects stack adjustment, perform this now.
128 // Normal frame unwinding would have included the offset already in the
129 // CFA computation.
130 // Note: for PA-RISC and other platforms where the stack grows up,
131 // this should actually be - info.gp. LLVM doesn't currently support
132 // any such platforms and Clang doesn't export a macro for them.
133 if (info.gp)
134 co->setReg(UNW_REG_SP, co->getReg(UNW_REG_SP) + info.gp);
135 }
136 return UNW_ESUCCESS;
137 }
138 return UNW_EBADREG;
139 }
_LIBUNWIND_WEAK_ALIAS(__unw_set_reg,unw_set_reg)140 _LIBUNWIND_WEAK_ALIAS(__unw_set_reg, unw_set_reg)
141
142 /// Get value of specified float register at cursor position in stack frame.
143 _LIBUNWIND_HIDDEN int __unw_get_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
144 unw_fpreg_t *value) {
145 _LIBUNWIND_TRACE_API("__unw_get_fpreg(cursor=%p, regNum=%d, &value=%p)",
146 static_cast<void *>(cursor), regNum,
147 static_cast<void *>(value));
148 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
149 if (co->validFloatReg(regNum)) {
150 *value = co->getFloatReg(regNum);
151 return UNW_ESUCCESS;
152 }
153 return UNW_EBADREG;
154 }
_LIBUNWIND_WEAK_ALIAS(__unw_get_fpreg,unw_get_fpreg)155 _LIBUNWIND_WEAK_ALIAS(__unw_get_fpreg, unw_get_fpreg)
156
157 /// Set value of specified float register at cursor position in stack frame.
158 _LIBUNWIND_HIDDEN int __unw_set_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
159 unw_fpreg_t value) {
160 #if defined(_LIBUNWIND_ARM_EHABI)
161 _LIBUNWIND_TRACE_API("__unw_set_fpreg(cursor=%p, regNum=%d, value=%llX)",
162 static_cast<void *>(cursor), regNum, value);
163 #else
164 _LIBUNWIND_TRACE_API("__unw_set_fpreg(cursor=%p, regNum=%d, value=%g)",
165 static_cast<void *>(cursor), regNum, value);
166 #endif
167 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
168 if (co->validFloatReg(regNum)) {
169 co->setFloatReg(regNum, value);
170 return UNW_ESUCCESS;
171 }
172 return UNW_EBADREG;
173 }
_LIBUNWIND_WEAK_ALIAS(__unw_set_fpreg,unw_set_fpreg)174 _LIBUNWIND_WEAK_ALIAS(__unw_set_fpreg, unw_set_fpreg)
175
176 /// Move cursor to next frame.
177 _LIBUNWIND_HIDDEN int __unw_step(unw_cursor_t *cursor) {
178 _LIBUNWIND_TRACE_API("__unw_step(cursor=%p)", static_cast<void *>(cursor));
179 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
180 return co->step();
181 }
_LIBUNWIND_WEAK_ALIAS(__unw_step,unw_step)182 _LIBUNWIND_WEAK_ALIAS(__unw_step, unw_step)
183
184 /// Get unwind info at cursor position in stack frame.
185 _LIBUNWIND_HIDDEN int __unw_get_proc_info(unw_cursor_t *cursor,
186 unw_proc_info_t *info) {
187 _LIBUNWIND_TRACE_API("__unw_get_proc_info(cursor=%p, &info=%p)",
188 static_cast<void *>(cursor), static_cast<void *>(info));
189 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
190 co->getInfo(info);
191 if (info->end_ip == 0)
192 return UNW_ENOINFO;
193 return UNW_ESUCCESS;
194 }
_LIBUNWIND_WEAK_ALIAS(__unw_get_proc_info,unw_get_proc_info)195 _LIBUNWIND_WEAK_ALIAS(__unw_get_proc_info, unw_get_proc_info)
196
197 /// Resume execution at cursor position (aka longjump).
198 _LIBUNWIND_HIDDEN int __unw_resume(unw_cursor_t *cursor) {
199 _LIBUNWIND_TRACE_API("__unw_resume(cursor=%p)", static_cast<void *>(cursor));
200 #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
201 // Inform the ASan runtime that now might be a good time to clean stuff up.
202 __asan_handle_no_return();
203 #endif
204 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
205 co->jumpto();
206 return UNW_EUNSPEC;
207 }
_LIBUNWIND_WEAK_ALIAS(__unw_resume,unw_resume)208 _LIBUNWIND_WEAK_ALIAS(__unw_resume, unw_resume)
209
210 /// Get name of function at cursor position in stack frame.
211 _LIBUNWIND_HIDDEN int __unw_get_proc_name(unw_cursor_t *cursor, char *buf,
212 size_t bufLen, unw_word_t *offset) {
213 _LIBUNWIND_TRACE_API("__unw_get_proc_name(cursor=%p, &buf=%p, bufLen=%lu)",
214 static_cast<void *>(cursor), static_cast<void *>(buf),
215 static_cast<unsigned long>(bufLen));
216 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
217 if (co->getFunctionName(buf, bufLen, offset))
218 return UNW_ESUCCESS;
219 return UNW_EUNSPEC;
220 }
_LIBUNWIND_WEAK_ALIAS(__unw_get_proc_name,unw_get_proc_name)221 _LIBUNWIND_WEAK_ALIAS(__unw_get_proc_name, unw_get_proc_name)
222
223 /// Checks if a register is a floating-point register.
224 _LIBUNWIND_HIDDEN int __unw_is_fpreg(unw_cursor_t *cursor,
225 unw_regnum_t regNum) {
226 _LIBUNWIND_TRACE_API("__unw_is_fpreg(cursor=%p, regNum=%d)",
227 static_cast<void *>(cursor), regNum);
228 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
229 return co->validFloatReg(regNum);
230 }
_LIBUNWIND_WEAK_ALIAS(__unw_is_fpreg,unw_is_fpreg)231 _LIBUNWIND_WEAK_ALIAS(__unw_is_fpreg, unw_is_fpreg)
232
233 /// Checks if a register is a floating-point register.
234 _LIBUNWIND_HIDDEN const char *__unw_regname(unw_cursor_t *cursor,
235 unw_regnum_t regNum) {
236 _LIBUNWIND_TRACE_API("__unw_regname(cursor=%p, regNum=%d)",
237 static_cast<void *>(cursor), regNum);
238 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
239 return co->getRegisterName(regNum);
240 }
_LIBUNWIND_WEAK_ALIAS(__unw_regname,unw_regname)241 _LIBUNWIND_WEAK_ALIAS(__unw_regname, unw_regname)
242
243 /// Checks if current frame is signal trampoline.
244 _LIBUNWIND_HIDDEN int __unw_is_signal_frame(unw_cursor_t *cursor) {
245 _LIBUNWIND_TRACE_API("__unw_is_signal_frame(cursor=%p)",
246 static_cast<void *>(cursor));
247 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
248 return co->isSignalFrame();
249 }
_LIBUNWIND_WEAK_ALIAS(__unw_is_signal_frame,unw_is_signal_frame)250 _LIBUNWIND_WEAK_ALIAS(__unw_is_signal_frame, unw_is_signal_frame)
251
252 #ifdef _AIX
253 _LIBUNWIND_EXPORT uintptr_t __unw_get_data_rel_base(unw_cursor_t *cursor) {
254 _LIBUNWIND_TRACE_API("unw_get_data_rel_base(cursor=%p)",
255 static_cast<void *>(cursor));
256 AbstractUnwindCursor *co = reinterpret_cast<AbstractUnwindCursor *>(cursor);
257 return co->getDataRelBase();
258 }
_LIBUNWIND_WEAK_ALIAS(__unw_get_data_rel_base,unw_get_data_rel_base)259 _LIBUNWIND_WEAK_ALIAS(__unw_get_data_rel_base, unw_get_data_rel_base)
260 #endif
261
262 #ifdef __arm__
263 // Save VFP registers d0-d15 using FSTMIADX instead of FSTMIADD
264 _LIBUNWIND_HIDDEN void __unw_save_vfp_as_X(unw_cursor_t *cursor) {
265 _LIBUNWIND_TRACE_API("__unw_get_fpreg_save_vfp_as_X(cursor=%p)",
266 static_cast<void *>(cursor));
267 AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
268 return co->saveVFPAsX();
269 }
_LIBUNWIND_WEAK_ALIAS(__unw_save_vfp_as_X,unw_save_vfp_as_X)270 _LIBUNWIND_WEAK_ALIAS(__unw_save_vfp_as_X, unw_save_vfp_as_X)
271 #endif
272
273
274 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
275 /// SPI: walks cached DWARF entries
276 _LIBUNWIND_HIDDEN void __unw_iterate_dwarf_unwind_cache(void (*func)(
277 unw_word_t ip_start, unw_word_t ip_end, unw_word_t fde, unw_word_t mh)) {
278 _LIBUNWIND_TRACE_API("__unw_iterate_dwarf_unwind_cache(func=%p)",
279 reinterpret_cast<void *>(func));
280 DwarfFDECache<LocalAddressSpace>::iterateCacheEntries(func);
281 }
_LIBUNWIND_WEAK_ALIAS(__unw_iterate_dwarf_unwind_cache,unw_iterate_dwarf_unwind_cache)282 _LIBUNWIND_WEAK_ALIAS(__unw_iterate_dwarf_unwind_cache,
283 unw_iterate_dwarf_unwind_cache)
284
285 /// IPI: for __register_frame()
286 void __unw_add_dynamic_fde(unw_word_t fde) {
287 CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
288 CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
289 const char *message = CFI_Parser<LocalAddressSpace>::decodeFDE(
290 LocalAddressSpace::sThisAddressSpace,
291 (LocalAddressSpace::pint_t) fde, &fdeInfo, &cieInfo);
292 if (message == NULL) {
293 // dynamically registered FDEs don't have a mach_header group they are in.
294 // Use fde as mh_group
295 unw_word_t mh_group = fdeInfo.fdeStart;
296 DwarfFDECache<LocalAddressSpace>::add((LocalAddressSpace::pint_t)mh_group,
297 fdeInfo.pcStart, fdeInfo.pcEnd,
298 fdeInfo.fdeStart);
299 } else {
300 _LIBUNWIND_DEBUG_LOG("__unw_add_dynamic_fde: bad fde: %s", message);
301 }
302 }
303
304 /// IPI: for __deregister_frame()
__unw_remove_dynamic_fde(unw_word_t fde)305 void __unw_remove_dynamic_fde(unw_word_t fde) {
306 // fde is own mh_group
307 DwarfFDECache<LocalAddressSpace>::removeAllIn((LocalAddressSpace::pint_t)fde);
308 }
309
__unw_add_dynamic_eh_frame_section(unw_word_t eh_frame_start)310 void __unw_add_dynamic_eh_frame_section(unw_word_t eh_frame_start) {
311 // The eh_frame section start serves as the mh_group
312 unw_word_t mh_group = eh_frame_start;
313 CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
314 CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
315 auto p = (LocalAddressSpace::pint_t)eh_frame_start;
316 while (true) {
317 if (CFI_Parser<LocalAddressSpace>::decodeFDE(
318 LocalAddressSpace::sThisAddressSpace, p, &fdeInfo, &cieInfo,
319 true) == NULL) {
320 DwarfFDECache<LocalAddressSpace>::add((LocalAddressSpace::pint_t)mh_group,
321 fdeInfo.pcStart, fdeInfo.pcEnd,
322 fdeInfo.fdeStart);
323 p += fdeInfo.fdeLength;
324 } else if (CFI_Parser<LocalAddressSpace>::parseCIE(
325 LocalAddressSpace::sThisAddressSpace, p, &cieInfo) == NULL) {
326 p += cieInfo.cieLength;
327 } else
328 return;
329 }
330 }
331
__unw_remove_dynamic_eh_frame_section(unw_word_t eh_frame_start)332 void __unw_remove_dynamic_eh_frame_section(unw_word_t eh_frame_start) {
333 // The eh_frame section start serves as the mh_group
334 DwarfFDECache<LocalAddressSpace>::removeAllIn(
335 (LocalAddressSpace::pint_t)eh_frame_start);
336 }
337
338 #endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
339 #endif // !defined(__USING_SJLJ_EXCEPTIONS__)
340
341
342
343 // Add logging hooks in Debug builds only
344 #ifndef NDEBUG
345 #include <stdlib.h>
346
347 _LIBUNWIND_HIDDEN
logAPIs()348 bool logAPIs() {
349 // do manual lock to avoid use of _cxa_guard_acquire or initializers
350 static bool checked = false;
351 static bool log = false;
352 if (!checked) {
353 log = (getenv("LIBUNWIND_PRINT_APIS") != NULL);
354 checked = true;
355 }
356 return log;
357 }
358
359 _LIBUNWIND_HIDDEN
logUnwinding()360 bool logUnwinding() {
361 // do manual lock to avoid use of _cxa_guard_acquire or initializers
362 static bool checked = false;
363 static bool log = false;
364 if (!checked) {
365 log = (getenv("LIBUNWIND_PRINT_UNWINDING") != NULL);
366 checked = true;
367 }
368 return log;
369 }
370
371 _LIBUNWIND_HIDDEN
logDWARF()372 bool logDWARF() {
373 // do manual lock to avoid use of _cxa_guard_acquire or initializers
374 static bool checked = false;
375 static bool log = false;
376 if (!checked) {
377 log = (getenv("LIBUNWIND_PRINT_DWARF") != NULL);
378 checked = true;
379 }
380 return log;
381 }
382
383 #endif // NDEBUG
384
385