contrib/libunwind/src/UnwindLevel1-gcc-ext.c

   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
  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
  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
  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".
  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
 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     __personality_routine handler = (__personality_routine) 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.
 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.
 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.
 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   *ipBefore = 0;
 225   return _Unwind_GetIP(context);
 226 }
 227
 228 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
 229
 230 #if defined(__FreeBSD__)
 231
 232 // Based on LLVM's lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp
 233 // and XXX should be fixed to be alignment-safe.
 234 static void processFDE(const char *addr, bool isDeregister) {
 235   uint64_t length;
 236   while ((length = *((const uint32_t *)addr)) != 0) {
 237     const char *p = addr + 4;
 238     if (length == 0xffffffff) {
 239       length = *((const uint64_t *)p);
 240       p += 8;
 241     }
 242     uint32_t offset = *((const uint32_t *)p);
 243     if (offset != 0) {
 244       if (isDeregister)
 245         __unw_remove_dynamic_fde((unw_word_t)(uintptr_t)addr);
 246       else
 247         __unw_add_dynamic_fde((unw_word_t)(uintptr_t)addr);
 248     }
 249     addr = p + length;
 250   }
 251 }
 252
 253 /// Called by programs with dynamic code generators that want to register
 254 /// dynamically generated FDEs, with a libgcc-compatible API.
 255
 256 _LIBUNWIND_EXPORT void __register_frame(const void *addr) {
 257   _LIBUNWIND_TRACE_API("__register_frame(%p)", addr);
 258   processFDE(addr, false);
 259 }
 260
 261 /// Called by programs with dynamic code generators that want to unregister
 262 /// dynamically generated FDEs, with a libgcc-compatible API.
 263 _LIBUNWIND_EXPORT void __deregister_frame(const void *addr) {
 264   _LIBUNWIND_TRACE_API("__deregister_frame(%p)", addr);
 265   processFDE(addr, true);
 266 }
 267
 268 #else // defined(__FreeBSD__)
 269
 270 /// Called by programs with dynamic code generators that want
 271 /// to register a dynamically generated FDE.
 272 /// This function has existed on Mac OS X since 10.4, but
 273 /// was broken until 10.6.
 274 _LIBUNWIND_EXPORT void __register_frame(const void *fde) {
 275   _LIBUNWIND_TRACE_API("__register_frame(%p)", fde);
 276   __unw_add_dynamic_fde((unw_word_t)(uintptr_t)fde);
 277 }
 278
 279 /// Called by programs with dynamic code generators that want
 280 /// to unregister a dynamically generated FDE.
 281 /// This function has existed on Mac OS X since 10.4, but
 282 /// was broken until 10.6.
 283 _LIBUNWIND_EXPORT void __deregister_frame(const void *fde) {
 284   _LIBUNWIND_TRACE_API("__deregister_frame(%p)", fde);
 285   __unw_remove_dynamic_fde((unw_word_t)(uintptr_t)fde);
 286 }
 287
 288 #endif // defined(__FreeBSD__)
 289
 290 // The following register/deregister functions are gcc extensions.
 291 // They have existed on Mac OS X, but have never worked because Mac OS X
 292 // before 10.6 used keymgr to track known FDEs, but these functions
 293 // never got updated to use keymgr.
 294 // For now, we implement these as do-nothing functions to keep any existing
 295 // applications working.  We also add the not in 10.6 symbol so that nwe
 296 // application won't be able to use them.
 297
 298 #if defined(_LIBUNWIND_SUPPORT_FRAME_APIS)
 299 _LIBUNWIND_EXPORT void __register_frame_info_bases(const void *fde, void *ob,
 300                                                    void *tb, void *db) {
 301   (void)fde;
 302   (void)ob;
 303   (void)tb;
 304   (void)db;
 305  _LIBUNWIND_TRACE_API("__register_frame_info_bases(%p,%p, %p, %p)",
 306                             fde, ob, tb, db);
 307   // do nothing, this function never worked in Mac OS X
 308 }
 309
 310 _LIBUNWIND_EXPORT void __register_frame_info(const void *fde, void *ob) {
 311   (void)fde;
 312   (void)ob;
 313   _LIBUNWIND_TRACE_API("__register_frame_info(%p, %p)", fde, ob);
 314   // do nothing, this function never worked in Mac OS X
 315 }
 316
 317 _LIBUNWIND_EXPORT void __register_frame_info_table_bases(const void *fde,
 318                                                          void *ob, void *tb,
 319                                                          void *db) {
 320   (void)fde;
 321   (void)ob;
 322   (void)tb;
 323   (void)db;
 324   _LIBUNWIND_TRACE_API("__register_frame_info_table_bases"
 325                              "(%p,%p, %p, %p)", fde, ob, tb, db);
 326   // do nothing, this function never worked in Mac OS X
 327 }
 328
 329 _LIBUNWIND_EXPORT void __register_frame_info_table(const void *fde, void *ob) {
 330   (void)fde;
 331   (void)ob;
 332   _LIBUNWIND_TRACE_API("__register_frame_info_table(%p, %p)", fde, ob);
 333   // do nothing, this function never worked in Mac OS X
 334 }
 335
 336 _LIBUNWIND_EXPORT void __register_frame_table(const void *fde) {
 337   (void)fde;
 338   _LIBUNWIND_TRACE_API("__register_frame_table(%p)", fde);
 339   // do nothing, this function never worked in Mac OS X
 340 }
 341
 342 _LIBUNWIND_EXPORT void *__deregister_frame_info(const void *fde) {
 343   (void)fde;
 344   _LIBUNWIND_TRACE_API("__deregister_frame_info(%p)", fde);
 345   // do nothing, this function never worked in Mac OS X
 346   return NULL;
 347 }
 348
 349 _LIBUNWIND_EXPORT void *__deregister_frame_info_bases(const void *fde) {
 350   (void)fde;
 351   _LIBUNWIND_TRACE_API("__deregister_frame_info_bases(%p)", fde);
 352   // do nothing, this function never worked in Mac OS X
 353   return NULL;
 354 }
 355 #endif // defined(_LIBUNWIND_SUPPORT_FRAME_APIS)
 356
 357 #endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
 358
 359 #endif // defined(_LIBUNWIND_BUILD_ZERO_COST_APIS)