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