xref: /freebsd/contrib/llvm-project/libunwind/src/UnwindLevel1-gcc-ext.c (revision 271171e0d97b88ba2a7c3bf750c9672b484c1c13)
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 gcc extensions to the C++ ABI Exception Handling Level 1.
9 //
10 //===----------------------------------------------------------------------===//
11 
12 #include <inttypes.h>
13 #include <stdbool.h>
14 #include <stdint.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 
19 #include "config.h"
20 #include "libunwind_ext.h"
21 #include "libunwind.h"
22 #include "Unwind-EHABI.h"
23 #include "unwind.h"
24 
25 #if defined(_LIBUNWIND_BUILD_ZERO_COST_APIS)
26 
27 #if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
28 #define PRIVATE_1 private_[0]
29 #elif defined(_LIBUNWIND_ARM_EHABI)
30 #define PRIVATE_1 unwinder_cache.reserved1
31 #else
32 #define PRIVATE_1 private_1
33 #endif
34 
35 ///  Called by __cxa_rethrow().
36 _LIBUNWIND_EXPORT _Unwind_Reason_Code
37 _Unwind_Resume_or_Rethrow(_Unwind_Exception *exception_object) {
38   _LIBUNWIND_TRACE_API(
39       "_Unwind_Resume_or_Rethrow(ex_obj=%p), private_1=%" PRIdPTR,
40       (void *)exception_object, (intptr_t)exception_object->PRIVATE_1);
41 
42   // If this is non-forced and a stopping place was found, then this is a
43   // re-throw.
44   // Call _Unwind_RaiseException() as if this was a new exception
45   if (exception_object->PRIVATE_1 == 0) {
46     return _Unwind_RaiseException(exception_object);
47     // Will return if there is no catch clause, so that __cxa_rethrow can call
48     // std::terminate().
49   }
50 
51   // Call through to _Unwind_Resume() which distiguishes between forced and
52   // regular exceptions.
53   _Unwind_Resume(exception_object);
54   _LIBUNWIND_ABORT("_Unwind_Resume_or_Rethrow() called _Unwind_RaiseException()"
55                    " which unexpectedly returned");
56 }
57 
58 /// Called by personality handler during phase 2 to get base address for data
59 /// relative encodings.
60 _LIBUNWIND_EXPORT uintptr_t
61 _Unwind_GetDataRelBase(struct _Unwind_Context *context) {
62   (void)context;
63   _LIBUNWIND_TRACE_API("_Unwind_GetDataRelBase(context=%p)", (void *)context);
64   _LIBUNWIND_ABORT("_Unwind_GetDataRelBase() not implemented");
65 }
66 
67 
68 /// Called by personality handler during phase 2 to get base address for text
69 /// relative encodings.
70 _LIBUNWIND_EXPORT uintptr_t
71 _Unwind_GetTextRelBase(struct _Unwind_Context *context) {
72   (void)context;
73   _LIBUNWIND_TRACE_API("_Unwind_GetTextRelBase(context=%p)", (void *)context);
74   _LIBUNWIND_ABORT("_Unwind_GetTextRelBase() not implemented");
75 }
76 
77 
78 /// Scans unwind information to find the function that contains the
79 /// specified code address "pc".
80 _LIBUNWIND_EXPORT void *_Unwind_FindEnclosingFunction(void *pc) {
81   _LIBUNWIND_TRACE_API("_Unwind_FindEnclosingFunction(pc=%p)", pc);
82   // This is slow, but works.
83   // We create an unwind cursor then alter the IP to be pc
84   unw_cursor_t cursor;
85   unw_context_t uc;
86   unw_proc_info_t info;
87   __unw_getcontext(&uc);
88   __unw_init_local(&cursor, &uc);
89   __unw_set_reg(&cursor, UNW_REG_IP, (unw_word_t)(intptr_t)pc);
90   if (__unw_get_proc_info(&cursor, &info) == UNW_ESUCCESS)
91     return (void *)(intptr_t) info.start_ip;
92   else
93     return NULL;
94 }
95 
96 /// Walk every frame and call trace function at each one.  If trace function
97 /// returns anything other than _URC_NO_REASON, then walk is terminated.
98 _LIBUNWIND_EXPORT _Unwind_Reason_Code
99 _Unwind_Backtrace(_Unwind_Trace_Fn callback, void *ref) {
100   unw_cursor_t cursor;
101   unw_context_t uc;
102   __unw_getcontext(&uc);
103   __unw_init_local(&cursor, &uc);
104 
105   _LIBUNWIND_TRACE_API("_Unwind_Backtrace(callback=%p)",
106                        (void *)(uintptr_t)callback);
107 
108 #if defined(_LIBUNWIND_ARM_EHABI)
109   // Create a mock exception object for force unwinding.
110   _Unwind_Exception ex;
111   memset(&ex, '\0', sizeof(ex));
112   strcpy((char *)&ex.exception_class, "CLNGUNW");
113 #endif
114 
115   // walk each frame
116   while (true) {
117     _Unwind_Reason_Code result;
118 
119 #if !defined(_LIBUNWIND_ARM_EHABI)
120     // ask libunwind to get next frame (skip over first frame which is
121     // _Unwind_Backtrace())
122     if (__unw_step(&cursor) <= 0) {
123       _LIBUNWIND_TRACE_UNWINDING(" _backtrace: ended because cursor reached "
124                                  "bottom of stack, returning %d",
125                                  _URC_END_OF_STACK);
126       return _URC_END_OF_STACK;
127     }
128 #else
129     // Get the information for this frame.
130     unw_proc_info_t frameInfo;
131     if (__unw_get_proc_info(&cursor, &frameInfo) != UNW_ESUCCESS) {
132       return _URC_END_OF_STACK;
133     }
134 
135     // Update the pr_cache in the mock exception object.
136     const uint32_t* unwindInfo = (uint32_t *) frameInfo.unwind_info;
137     ex.pr_cache.fnstart = frameInfo.start_ip;
138     ex.pr_cache.ehtp = (_Unwind_EHT_Header *) unwindInfo;
139     ex.pr_cache.additional= frameInfo.flags;
140 
141     struct _Unwind_Context *context = (struct _Unwind_Context *)&cursor;
142     // Get and call the personality function to unwind the frame.
143     _Unwind_Personality_Fn handler = (_Unwind_Personality_Fn)frameInfo.handler;
144     if (handler == NULL) {
145       return _URC_END_OF_STACK;
146     }
147     if (handler(_US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND, &ex, context) !=
148             _URC_CONTINUE_UNWIND) {
149       return _URC_END_OF_STACK;
150     }
151 #endif // defined(_LIBUNWIND_ARM_EHABI)
152 
153     // debugging
154     if (_LIBUNWIND_TRACING_UNWINDING) {
155       char functionName[512];
156       unw_proc_info_t frame;
157       unw_word_t offset;
158       __unw_get_proc_name(&cursor, functionName, 512, &offset);
159       __unw_get_proc_info(&cursor, &frame);
160       _LIBUNWIND_TRACE_UNWINDING(
161           " _backtrace: start_ip=0x%" PRIxPTR ", func=%s, lsda=0x%" PRIxPTR ", context=%p",
162           frame.start_ip, functionName, frame.lsda,
163           (void *)&cursor);
164     }
165 
166     // call trace function with this frame
167     result = (*callback)((struct _Unwind_Context *)(&cursor), ref);
168     if (result != _URC_NO_REASON) {
169       _LIBUNWIND_TRACE_UNWINDING(
170           " _backtrace: ended because callback returned %d", result);
171       return result;
172     }
173   }
174 }
175 #ifdef __arm__
176 /* Preserve legacy libgcc (pre r318024) ARM ABI mistake */
177 __sym_compat(_Unwind_Backtrace, _Unwind_Backtrace, GCC_3.3);
178 #endif
179 
180 
181 /// Find DWARF unwind info for an address 'pc' in some function.
182 _LIBUNWIND_EXPORT const void *_Unwind_Find_FDE(const void *pc,
183                                                struct dwarf_eh_bases *bases) {
184   // This is slow, but works.
185   // We create an unwind cursor then alter the IP to be pc
186   unw_cursor_t cursor;
187   unw_context_t uc;
188   unw_proc_info_t info;
189   __unw_getcontext(&uc);
190   __unw_init_local(&cursor, &uc);
191   __unw_set_reg(&cursor, UNW_REG_IP, (unw_word_t)(intptr_t)pc);
192   __unw_get_proc_info(&cursor, &info);
193   bases->tbase = (uintptr_t)info.extra;
194   bases->dbase = 0; // dbase not used on Mac OS X
195   bases->func = (uintptr_t)info.start_ip;
196   _LIBUNWIND_TRACE_API("_Unwind_Find_FDE(pc=%p) => %p", pc,
197                   (void *)(intptr_t) info.unwind_info);
198   return (void *)(intptr_t) info.unwind_info;
199 }
200 
201 /// Returns the CFA (call frame area, or stack pointer at start of function)
202 /// for the current context.
203 _LIBUNWIND_EXPORT uintptr_t _Unwind_GetCFA(struct _Unwind_Context *context) {
204   unw_cursor_t *cursor = (unw_cursor_t *)context;
205   unw_word_t result;
206   __unw_get_reg(cursor, UNW_REG_SP, &result);
207   _LIBUNWIND_TRACE_API("_Unwind_GetCFA(context=%p) => 0x%" PRIxPTR,
208                        (void *)context, result);
209   return (uintptr_t)result;
210 }
211 
212 
213 /// Called by personality handler during phase 2 to get instruction pointer.
214 /// ipBefore is a boolean that says if IP is already adjusted to be the call
215 /// site address.  Normally IP is the return address.
216 _LIBUNWIND_EXPORT uintptr_t _Unwind_GetIPInfo(struct _Unwind_Context *context,
217                                               int *ipBefore) {
218   _LIBUNWIND_TRACE_API("_Unwind_GetIPInfo(context=%p)", (void *)context);
219   int isSignalFrame = __unw_is_signal_frame((unw_cursor_t *)context);
220   // Negative means some kind of error (probably UNW_ENOINFO), but we have no
221   // good way to report that, and this maintains backward compatibility with the
222   // implementation that hard-coded zero in every case, even signal frames.
223   if (isSignalFrame <= 0)
224     *ipBefore = 0;
225   else
226     *ipBefore = 1;
227   return _Unwind_GetIP(context);
228 }
229 
230 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
231 
232 #if defined(__FreeBSD__)
233 
234 // Based on LLVM's lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp
235 // and XXX should be fixed to be alignment-safe.
236 static void processFDE(const char *addr, bool isDeregister) {
237   uint64_t length;
238   while ((length = *((const uint32_t *)addr)) != 0) {
239     const char *p = addr + 4;
240     if (length == 0xffffffff) {
241       length = *((const uint64_t *)p);
242       p += 8;
243     }
244     uint32_t offset = *((const uint32_t *)p);
245     if (offset != 0) {
246       if (isDeregister)
247         __unw_remove_dynamic_fde((unw_word_t)(uintptr_t)addr);
248       else
249         __unw_add_dynamic_fde((unw_word_t)(uintptr_t)addr);
250     }
251     addr = p + length;
252   }
253 }
254 
255 /// Called by programs with dynamic code generators that want to register
256 /// dynamically generated FDEs, with a libgcc-compatible API.
257 
258 _LIBUNWIND_EXPORT void __register_frame(const void *addr) {
259   _LIBUNWIND_TRACE_API("__register_frame(%p)", addr);
260   processFDE(addr, false);
261 }
262 
263 /// Called by programs with dynamic code generators that want to unregister
264 /// dynamically generated FDEs, with a libgcc-compatible API.
265 _LIBUNWIND_EXPORT void __deregister_frame(const void *addr) {
266   _LIBUNWIND_TRACE_API("__deregister_frame(%p)", addr);
267   processFDE(addr, true);
268 }
269 
270 #else // defined(__FreeBSD__)
271 
272 /// Called by programs with dynamic code generators that want
273 /// to register a dynamically generated FDE.
274 /// This function has existed on Mac OS X since 10.4, but
275 /// was broken until 10.6.
276 _LIBUNWIND_EXPORT void __register_frame(const void *fde) {
277   _LIBUNWIND_TRACE_API("__register_frame(%p)", fde);
278   __unw_add_dynamic_fde((unw_word_t)(uintptr_t)fde);
279 }
280 
281 /// Called by programs with dynamic code generators that want
282 /// to unregister a dynamically generated FDE.
283 /// This function has existed on Mac OS X since 10.4, but
284 /// was broken until 10.6.
285 _LIBUNWIND_EXPORT void __deregister_frame(const void *fde) {
286   _LIBUNWIND_TRACE_API("__deregister_frame(%p)", fde);
287   __unw_remove_dynamic_fde((unw_word_t)(uintptr_t)fde);
288 }
289 
290 #endif // defined(__FreeBSD__)
291 
292 // The following register/deregister functions are gcc extensions.
293 // They have existed on Mac OS X, but have never worked because Mac OS X
294 // before 10.6 used keymgr to track known FDEs, but these functions
295 // never got updated to use keymgr.
296 // For now, we implement these as do-nothing functions to keep any existing
297 // applications working.  We also add the not in 10.6 symbol so that nwe
298 // application won't be able to use them.
299 
300 #if defined(_LIBUNWIND_SUPPORT_FRAME_APIS)
301 _LIBUNWIND_EXPORT void __register_frame_info_bases(const void *fde, void *ob,
302                                                    void *tb, void *db) {
303   (void)fde;
304   (void)ob;
305   (void)tb;
306   (void)db;
307  _LIBUNWIND_TRACE_API("__register_frame_info_bases(%p,%p, %p, %p)",
308                             fde, ob, tb, db);
309   // do nothing, this function never worked in Mac OS X
310 }
311 
312 _LIBUNWIND_EXPORT void __register_frame_info(const void *fde, void *ob) {
313   (void)fde;
314   (void)ob;
315   _LIBUNWIND_TRACE_API("__register_frame_info(%p, %p)", fde, ob);
316   // do nothing, this function never worked in Mac OS X
317 }
318 
319 _LIBUNWIND_EXPORT void __register_frame_info_table_bases(const void *fde,
320                                                          void *ob, void *tb,
321                                                          void *db) {
322   (void)fde;
323   (void)ob;
324   (void)tb;
325   (void)db;
326   _LIBUNWIND_TRACE_API("__register_frame_info_table_bases"
327                              "(%p,%p, %p, %p)", fde, ob, tb, db);
328   // do nothing, this function never worked in Mac OS X
329 }
330 
331 _LIBUNWIND_EXPORT void __register_frame_info_table(const void *fde, void *ob) {
332   (void)fde;
333   (void)ob;
334   _LIBUNWIND_TRACE_API("__register_frame_info_table(%p, %p)", fde, ob);
335   // do nothing, this function never worked in Mac OS X
336 }
337 
338 _LIBUNWIND_EXPORT void __register_frame_table(const void *fde) {
339   (void)fde;
340   _LIBUNWIND_TRACE_API("__register_frame_table(%p)", fde);
341   // do nothing, this function never worked in Mac OS X
342 }
343 
344 _LIBUNWIND_EXPORT void *__deregister_frame_info(const void *fde) {
345   (void)fde;
346   _LIBUNWIND_TRACE_API("__deregister_frame_info(%p)", fde);
347   // do nothing, this function never worked in Mac OS X
348   return NULL;
349 }
350 
351 _LIBUNWIND_EXPORT void *__deregister_frame_info_bases(const void *fde) {
352   (void)fde;
353   _LIBUNWIND_TRACE_API("__deregister_frame_info_bases(%p)", fde);
354   // do nothing, this function never worked in Mac OS X
355   return NULL;
356 }
357 #endif // defined(_LIBUNWIND_SUPPORT_FRAME_APIS)
358 
359 #endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
360 
361 #endif // defined(_LIBUNWIND_BUILD_ZERO_COST_APIS)
362