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

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