contrib/llvm-project/libunwind/src/libunwind.cpp

   1 //===--------------------------- libunwind.cpp ----------------------------===//
   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 unw_* functions from <libunwind.h>
   9 //
  10 //===----------------------------------------------------------------------===//
  11
  12 #include <libunwind.h>
  13
  14 #include "libunwind_ext.h"
  15 #include "config.h"
  16
  17 #include <stdlib.h>
  18
  19
  20 #if !defined(__USING_SJLJ_EXCEPTIONS__)
  21 #include "AddressSpace.hpp"
  22 #include "UnwindCursor.hpp"
  23
  24 using namespace libunwind;
  25
  26 /// internal object to represent this processes address space
  27 LocalAddressSpace LocalAddressSpace::sThisAddressSpace;
  28
  29 _LIBUNWIND_EXPORT unw_addr_space_t unw_local_addr_space =
  30     (unw_addr_space_t)&LocalAddressSpace::sThisAddressSpace;
  31
  32 /// Create a cursor of a thread in this process given 'context' recorded by
  33 /// __unw_getcontext().
  34 _LIBUNWIND_HIDDEN int __unw_init_local(unw_cursor_t *cursor,
  35                                        unw_context_t *context) {
  36   _LIBUNWIND_TRACE_API("__unw_init_local(cursor=%p, context=%p)",
  37                        static_cast<void *>(cursor),
  38                        static_cast<void *>(context));
  39 #if defined(__i386__)
  40 # define REGISTER_KIND Registers_x86
  41 #elif defined(__x86_64__)
  42 # define REGISTER_KIND Registers_x86_64
  43 #elif defined(__powerpc64__)
  44 # define REGISTER_KIND Registers_ppc64
  45 #elif defined(__ppc__)
  46 # define REGISTER_KIND Registers_ppc
  47 #elif defined(__aarch64__)
  48 # define REGISTER_KIND Registers_arm64
  49 #elif defined(__arm__)
  50 # define REGISTER_KIND Registers_arm
  51 #elif defined(__or1k__)
  52 # define REGISTER_KIND Registers_or1k
  53 #elif defined(__riscv)
  54 # define REGISTER_KIND Registers_riscv
  55 #elif defined(__mips__) && defined(_ABIO32) && _MIPS_SIM == _ABIO32
  56 # define REGISTER_KIND Registers_mips_o32
  57 #elif defined(__mips64)
  58 # define REGISTER_KIND Registers_mips_newabi
  59 #elif defined(__mips__)
  60 # warning The MIPS architecture is not supported with this ABI and environment!
  61 #elif defined(__sparc__)
  62 # define REGISTER_KIND Registers_sparc
  63 #else
  64 # error Architecture not supported
  65 #endif
  66   // Use "placement new" to allocate UnwindCursor in the cursor buffer.
  67   new (reinterpret_cast<UnwindCursor<LocalAddressSpace, REGISTER_KIND> *>(cursor))
  68       UnwindCursor<LocalAddressSpace, REGISTER_KIND>(
  69           context, LocalAddressSpace::sThisAddressSpace);
  70 #undef REGISTER_KIND
  71   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
  72   co->setInfoBasedOnIPRegister();
  73
  74   return UNW_ESUCCESS;
  75 }
  76 _LIBUNWIND_WEAK_ALIAS(__unw_init_local, unw_init_local)
  77
  78 /// Get value of specified register at cursor position in stack frame.
  79 _LIBUNWIND_HIDDEN int __unw_get_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
  80                                     unw_word_t *value) {
  81   _LIBUNWIND_TRACE_API("__unw_get_reg(cursor=%p, regNum=%d, &value=%p)",
  82                        static_cast<void *>(cursor), regNum,
  83                        static_cast<void *>(value));
  84   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
  85   if (co->validReg(regNum)) {
  86     *value = co->getReg(regNum);
  87     return UNW_ESUCCESS;
  88   }
  89   return UNW_EBADREG;
  90 }
  91 _LIBUNWIND_WEAK_ALIAS(__unw_get_reg, unw_get_reg)
  92
  93 /// Set value of specified register at cursor position in stack frame.
  94 _LIBUNWIND_HIDDEN int __unw_set_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
  95                                     unw_word_t value) {
  96   _LIBUNWIND_TRACE_API("__unw_set_reg(cursor=%p, regNum=%d, value=0x%" PRIxPTR
  97                        ")",
  98                        static_cast<void *>(cursor), regNum, value);
  99   typedef LocalAddressSpace::pint_t pint_t;
 100   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 101   if (co->validReg(regNum)) {
 102     co->setReg(regNum, (pint_t)value);
 103     // specical case altering IP to re-find info (being called by personality
 104     // function)
 105     if (regNum == UNW_REG_IP) {
 106       unw_proc_info_t info;
 107       // First, get the FDE for the old location and then update it.
 108       co->getInfo(&info);
 109       co->setInfoBasedOnIPRegister(false);
 110       // If the original call expects stack adjustment, perform this now.
 111       // Normal frame unwinding would have included the offset already in the
 112       // CFA computation.
 113       // Note: for PA-RISC and other platforms where the stack grows up,
 114       // this should actually be - info.gp. LLVM doesn't currently support
 115       // any such platforms and Clang doesn't export a macro for them.
 116       if (info.gp)
 117         co->setReg(UNW_REG_SP, co->getReg(UNW_REG_SP) + info.gp);
 118     }
 119     return UNW_ESUCCESS;
 120   }
 121   return UNW_EBADREG;
 122 }
 123 _LIBUNWIND_WEAK_ALIAS(__unw_set_reg, unw_set_reg)
 124
 125 /// Get value of specified float register at cursor position in stack frame.
 126 _LIBUNWIND_HIDDEN int __unw_get_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
 127                                       unw_fpreg_t *value) {
 128   _LIBUNWIND_TRACE_API("__unw_get_fpreg(cursor=%p, regNum=%d, &value=%p)",
 129                        static_cast<void *>(cursor), regNum,
 130                        static_cast<void *>(value));
 131   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 132   if (co->validFloatReg(regNum)) {
 133     *value = co->getFloatReg(regNum);
 134     return UNW_ESUCCESS;
 135   }
 136   return UNW_EBADREG;
 137 }
 138 _LIBUNWIND_WEAK_ALIAS(__unw_get_fpreg, unw_get_fpreg)
 139
 140 /// Set value of specified float register at cursor position in stack frame.
 141 _LIBUNWIND_HIDDEN int __unw_set_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
 142                                       unw_fpreg_t value) {
 143 #if defined(_LIBUNWIND_ARM_EHABI)
 144   _LIBUNWIND_TRACE_API("__unw_set_fpreg(cursor=%p, regNum=%d, value=%llX)",
 145                        static_cast<void *>(cursor), regNum, value);
 146 #else
 147   _LIBUNWIND_TRACE_API("__unw_set_fpreg(cursor=%p, regNum=%d, value=%g)",
 148                        static_cast<void *>(cursor), regNum, value);
 149 #endif
 150   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 151   if (co->validFloatReg(regNum)) {
 152     co->setFloatReg(regNum, value);
 153     return UNW_ESUCCESS;
 154   }
 155   return UNW_EBADREG;
 156 }
 157 _LIBUNWIND_WEAK_ALIAS(__unw_set_fpreg, unw_set_fpreg)
 158
 159 /// Move cursor to next frame.
 160 _LIBUNWIND_HIDDEN int __unw_step(unw_cursor_t *cursor) {
 161   _LIBUNWIND_TRACE_API("__unw_step(cursor=%p)", static_cast<void *>(cursor));
 162   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 163   return co->step();
 164 }
 165 _LIBUNWIND_WEAK_ALIAS(__unw_step, unw_step)
 166
 167 /// Get unwind info at cursor position in stack frame.
 168 _LIBUNWIND_HIDDEN int __unw_get_proc_info(unw_cursor_t *cursor,
 169                                           unw_proc_info_t *info) {
 170   _LIBUNWIND_TRACE_API("__unw_get_proc_info(cursor=%p, &info=%p)",
 171                        static_cast<void *>(cursor), static_cast<void *>(info));
 172   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 173   co->getInfo(info);
 174   if (info->end_ip == 0)
 175     return UNW_ENOINFO;
 176   else
 177     return UNW_ESUCCESS;
 178 }
 179 _LIBUNWIND_WEAK_ALIAS(__unw_get_proc_info, unw_get_proc_info)
 180
 181 /// Resume execution at cursor position (aka longjump).
 182 _LIBUNWIND_HIDDEN int __unw_resume(unw_cursor_t *cursor) {
 183   _LIBUNWIND_TRACE_API("__unw_resume(cursor=%p)", static_cast<void *>(cursor));
 184   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 185   co->jumpto();
 186   return UNW_EUNSPEC;
 187 }
 188 _LIBUNWIND_WEAK_ALIAS(__unw_resume, unw_resume)
 189
 190 /// Get name of function at cursor position in stack frame.
 191 _LIBUNWIND_HIDDEN int __unw_get_proc_name(unw_cursor_t *cursor, char *buf,
 192                                           size_t bufLen, unw_word_t *offset) {
 193   _LIBUNWIND_TRACE_API("__unw_get_proc_name(cursor=%p, &buf=%p, bufLen=%lu)",
 194                        static_cast<void *>(cursor), static_cast<void *>(buf),
 195                        static_cast<unsigned long>(bufLen));
 196   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 197   if (co->getFunctionName(buf, bufLen, offset))
 198     return UNW_ESUCCESS;
 199   else
 200     return UNW_EUNSPEC;
 201 }
 202 _LIBUNWIND_WEAK_ALIAS(__unw_get_proc_name, unw_get_proc_name)
 203
 204 /// Checks if a register is a floating-point register.
 205 _LIBUNWIND_HIDDEN int __unw_is_fpreg(unw_cursor_t *cursor,
 206                                      unw_regnum_t regNum) {
 207   _LIBUNWIND_TRACE_API("__unw_is_fpreg(cursor=%p, regNum=%d)",
 208                        static_cast<void *>(cursor), regNum);
 209   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 210   return co->validFloatReg(regNum);
 211 }
 212 _LIBUNWIND_WEAK_ALIAS(__unw_is_fpreg, unw_is_fpreg)
 213
 214 /// Checks if a register is a floating-point register.
 215 _LIBUNWIND_HIDDEN const char *__unw_regname(unw_cursor_t *cursor,
 216                                             unw_regnum_t regNum) {
 217   _LIBUNWIND_TRACE_API("__unw_regname(cursor=%p, regNum=%d)",
 218                        static_cast<void *>(cursor), regNum);
 219   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 220   return co->getRegisterName(regNum);
 221 }
 222 _LIBUNWIND_WEAK_ALIAS(__unw_regname, unw_regname)
 223
 224 /// Checks if current frame is signal trampoline.
 225 _LIBUNWIND_HIDDEN int __unw_is_signal_frame(unw_cursor_t *cursor) {
 226   _LIBUNWIND_TRACE_API("__unw_is_signal_frame(cursor=%p)",
 227                        static_cast<void *>(cursor));
 228   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 229   return co->isSignalFrame();
 230 }
 231 _LIBUNWIND_WEAK_ALIAS(__unw_is_signal_frame, unw_is_signal_frame)
 232
 233 #ifdef __arm__
 234 // Save VFP registers d0-d15 using FSTMIADX instead of FSTMIADD
 235 _LIBUNWIND_HIDDEN void __unw_save_vfp_as_X(unw_cursor_t *cursor) {
 236   _LIBUNWIND_TRACE_API("__unw_get_fpreg_save_vfp_as_X(cursor=%p)",
 237                        static_cast<void *>(cursor));
 238   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 239   return co->saveVFPAsX();
 240 }
 241 _LIBUNWIND_WEAK_ALIAS(__unw_save_vfp_as_X, unw_save_vfp_as_X)
 242 #endif
 243
 244
 245 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
 246 /// SPI: walks cached DWARF entries
 247 _LIBUNWIND_HIDDEN void __unw_iterate_dwarf_unwind_cache(void (*func)(
 248     unw_word_t ip_start, unw_word_t ip_end, unw_word_t fde, unw_word_t mh)) {
 249   _LIBUNWIND_TRACE_API("__unw_iterate_dwarf_unwind_cache(func=%p)",
 250                        reinterpret_cast<void *>(func));
 251   DwarfFDECache<LocalAddressSpace>::iterateCacheEntries(func);
 252 }
 253 _LIBUNWIND_WEAK_ALIAS(__unw_iterate_dwarf_unwind_cache,
 254                       unw_iterate_dwarf_unwind_cache)
 255
 256 /// IPI: for __register_frame()
 257 void __unw_add_dynamic_fde(unw_word_t fde) {
 258   CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
 259   CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
 260   const char *message = CFI_Parser<LocalAddressSpace>::decodeFDE(
 261                            LocalAddressSpace::sThisAddressSpace,
 262                           (LocalAddressSpace::pint_t) fde, &fdeInfo, &cieInfo);
 263   if (message == NULL) {
 264     // dynamically registered FDEs don't have a mach_header group they are in.
 265     // Use fde as mh_group
 266     unw_word_t mh_group = fdeInfo.fdeStart;
 267     DwarfFDECache<LocalAddressSpace>::add((LocalAddressSpace::pint_t)mh_group,
 268                                           fdeInfo.pcStart, fdeInfo.pcEnd,
 269                                           fdeInfo.fdeStart);
 270   } else {
 271     _LIBUNWIND_DEBUG_LOG("__unw_add_dynamic_fde: bad fde: %s", message);
 272   }
 273 }
 274
 275 /// IPI: for __deregister_frame()
 276 void __unw_remove_dynamic_fde(unw_word_t fde) {
 277   // fde is own mh_group
 278   DwarfFDECache<LocalAddressSpace>::removeAllIn((LocalAddressSpace::pint_t)fde);
 279 }
 280 #endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
 281 #endif // !defined(__USING_SJLJ_EXCEPTIONS__)
 282
 283
 284
 285 // Add logging hooks in Debug builds only
 286 #ifndef NDEBUG
 287 #include <stdlib.h>
 288
 289 _LIBUNWIND_HIDDEN
 290 bool logAPIs() {
 291   // do manual lock to avoid use of _cxa_guard_acquire or initializers
 292   static bool checked = false;
 293   static bool log = false;
 294   if (!checked) {
 295     log = (getenv("LIBUNWIND_PRINT_APIS") != NULL);
 296     checked = true;
 297   }
 298   return log;
 299 }
 300
 301 _LIBUNWIND_HIDDEN
 302 bool logUnwinding() {
 303   // do manual lock to avoid use of _cxa_guard_acquire or initializers
 304   static bool checked = false;
 305   static bool log = false;
 306   if (!checked) {
 307     log = (getenv("LIBUNWIND_PRINT_UNWINDING") != NULL);
 308     checked = true;
 309   }
 310   return log;
 311 }
 312
 313 _LIBUNWIND_HIDDEN
 314 bool logDWARF() {
 315   // do manual lock to avoid use of _cxa_guard_acquire or initializers
 316   static bool checked = false;
 317   static bool log = false;
 318   if (!checked) {
 319     log = (getenv("LIBUNWIND_PRINT_DWARF") != NULL);
 320     checked = true;
 321   }
 322   return log;
 323 }
 324
 325 #endif // NDEBUG
 326