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