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 #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 176 177 /// Find DWARF unwind info for an address 'pc' in some function. 178 _LIBUNWIND_EXPORT const void *_Unwind_Find_FDE(const void *pc, 179 struct dwarf_eh_bases *bases) { 180 // This is slow, but works. 181 // We create an unwind cursor then alter the IP to be pc 182 unw_cursor_t cursor; 183 unw_context_t uc; 184 unw_proc_info_t info; 185 __unw_getcontext(&uc); 186 __unw_init_local(&cursor, &uc); 187 __unw_set_reg(&cursor, UNW_REG_IP, (unw_word_t)(intptr_t)pc); 188 __unw_get_proc_info(&cursor, &info); 189 bases->tbase = (uintptr_t)info.extra; 190 bases->dbase = 0; // dbase not used on Mac OS X 191 bases->func = (uintptr_t)info.start_ip; 192 _LIBUNWIND_TRACE_API("_Unwind_Find_FDE(pc=%p) => %p", pc, 193 (void *)(intptr_t) info.unwind_info); 194 return (void *)(intptr_t) info.unwind_info; 195 } 196 197 /// Returns the CFA (call frame area, or stack pointer at start of function) 198 /// for the current context. 199 _LIBUNWIND_EXPORT uintptr_t _Unwind_GetCFA(struct _Unwind_Context *context) { 200 unw_cursor_t *cursor = (unw_cursor_t *)context; 201 unw_word_t result; 202 __unw_get_reg(cursor, UNW_REG_SP, &result); 203 _LIBUNWIND_TRACE_API("_Unwind_GetCFA(context=%p) => 0x%" PRIxPTR, 204 (void *)context, result); 205 return (uintptr_t)result; 206 } 207 208 209 /// Called by personality handler during phase 2 to get instruction pointer. 210 /// ipBefore is a boolean that says if IP is already adjusted to be the call 211 /// site address. Normally IP is the return address. 212 _LIBUNWIND_EXPORT uintptr_t _Unwind_GetIPInfo(struct _Unwind_Context *context, 213 int *ipBefore) { 214 _LIBUNWIND_TRACE_API("_Unwind_GetIPInfo(context=%p)", (void *)context); 215 int isSignalFrame = __unw_is_signal_frame((unw_cursor_t *)context); 216 // Negative means some kind of error (probably UNW_ENOINFO), but we have no 217 // good way to report that, and this maintains backward compatibility with the 218 // implementation that hard-coded zero in every case, even signal frames. 219 if (isSignalFrame <= 0) 220 *ipBefore = 0; 221 else 222 *ipBefore = 1; 223 return _Unwind_GetIP(context); 224 } 225 226 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 227 228 /// Called by programs with dynamic code generators that want 229 /// to register a dynamically generated FDE. 230 /// This function has existed on Mac OS X since 10.4, but 231 /// was broken until 10.6. 232 _LIBUNWIND_EXPORT void __register_frame(const void *fde) { 233 _LIBUNWIND_TRACE_API("__register_frame(%p)", fde); 234 __unw_add_dynamic_fde((unw_word_t)(uintptr_t)fde); 235 } 236 237 238 /// Called by programs with dynamic code generators that want 239 /// to unregister a dynamically generated FDE. 240 /// This function has existed on Mac OS X since 10.4, but 241 /// was broken until 10.6. 242 _LIBUNWIND_EXPORT void __deregister_frame(const void *fde) { 243 _LIBUNWIND_TRACE_API("__deregister_frame(%p)", fde); 244 __unw_remove_dynamic_fde((unw_word_t)(uintptr_t)fde); 245 } 246 247 248 // The following register/deregister functions are gcc extensions. 249 // They have existed on Mac OS X, but have never worked because Mac OS X 250 // before 10.6 used keymgr to track known FDEs, but these functions 251 // never got updated to use keymgr. 252 // For now, we implement these as do-nothing functions to keep any existing 253 // applications working. We also add the not in 10.6 symbol so that nwe 254 // application won't be able to use them. 255 256 #if defined(_LIBUNWIND_SUPPORT_FRAME_APIS) 257 _LIBUNWIND_EXPORT void __register_frame_info_bases(const void *fde, void *ob, 258 void *tb, void *db) { 259 (void)fde; 260 (void)ob; 261 (void)tb; 262 (void)db; 263 _LIBUNWIND_TRACE_API("__register_frame_info_bases(%p,%p, %p, %p)", 264 fde, ob, tb, db); 265 // do nothing, this function never worked in Mac OS X 266 } 267 268 _LIBUNWIND_EXPORT void __register_frame_info(const void *fde, void *ob) { 269 (void)fde; 270 (void)ob; 271 _LIBUNWIND_TRACE_API("__register_frame_info(%p, %p)", fde, ob); 272 // do nothing, this function never worked in Mac OS X 273 } 274 275 _LIBUNWIND_EXPORT void __register_frame_info_table_bases(const void *fde, 276 void *ob, void *tb, 277 void *db) { 278 (void)fde; 279 (void)ob; 280 (void)tb; 281 (void)db; 282 _LIBUNWIND_TRACE_API("__register_frame_info_table_bases" 283 "(%p,%p, %p, %p)", fde, ob, tb, db); 284 // do nothing, this function never worked in Mac OS X 285 } 286 287 _LIBUNWIND_EXPORT void __register_frame_info_table(const void *fde, void *ob) { 288 (void)fde; 289 (void)ob; 290 _LIBUNWIND_TRACE_API("__register_frame_info_table(%p, %p)", fde, ob); 291 // do nothing, this function never worked in Mac OS X 292 } 293 294 _LIBUNWIND_EXPORT void __register_frame_table(const void *fde) { 295 (void)fde; 296 _LIBUNWIND_TRACE_API("__register_frame_table(%p)", fde); 297 // do nothing, this function never worked in Mac OS X 298 } 299 300 _LIBUNWIND_EXPORT void *__deregister_frame_info(const void *fde) { 301 (void)fde; 302 _LIBUNWIND_TRACE_API("__deregister_frame_info(%p)", fde); 303 // do nothing, this function never worked in Mac OS X 304 return NULL; 305 } 306 307 _LIBUNWIND_EXPORT void *__deregister_frame_info_bases(const void *fde) { 308 (void)fde; 309 _LIBUNWIND_TRACE_API("__deregister_frame_info_bases(%p)", fde); 310 // do nothing, this function never worked in Mac OS X 311 return NULL; 312 } 313 #endif // defined(_LIBUNWIND_SUPPORT_FRAME_APIS) 314 315 #endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) 316 317 #endif // defined(_LIBUNWIND_BUILD_ZERO_COST_APIS) 318