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