src/third_party/libc++abi/trunk/src/Unwind/libunwind.cpp

   1 //===--------------------------- libuwind.cpp -----------------------------===//
   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 unw_* functions from <libunwind.h>
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include <libunwind.h>
  14
  15 #ifndef NDEBUG
  16 #include <cstdlib> // getenv
  17 #endif
  18 #include <new>
  19
  20 #include "libunwind_ext.h"
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24
  25
  26 #if _LIBUNWIND_BUILD_ZERO_COST_APIS
  27
  28 #include "UnwindCursor.hpp"
  29
  30 using namespace libunwind;
  31
  32 /// internal object to represent this processes address space
  33 LocalAddressSpace LocalAddressSpace::sThisAddressSpace;
  34
  35 /// record the registers and stack position of the caller
  36 extern int unw_getcontext(unw_context_t *);
  37 // note: unw_getcontext() implemented in assembly
  38
  39 /// Create a cursor of a thread in this process given 'context' recorded by
  40 /// unw_getcontext().
  41 _LIBUNWIND_EXPORT int unw_init_local(unw_cursor_t *cursor,
  42                                      unw_context_t *context) {
  43   _LIBUNWIND_TRACE_API("unw_init_local(cursor=%p, context=%p)\n",
  44                               cursor, context);
  45   // Use "placement new" to allocate UnwindCursor in the cursor buffer.
  46 #if __i386__
  47   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_x86>(
  48                                  context, LocalAddressSpace::sThisAddressSpace);
  49 #elif __x86_64__
  50   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_x86_64>(
  51                                  context, LocalAddressSpace::sThisAddressSpace);
  52 #elif __ppc__
  53   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_ppc>(
  54                                  context, LocalAddressSpace::sThisAddressSpace);
  55 #elif __arm64__
  56   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm64>(
  57                                  context, LocalAddressSpace::sThisAddressSpace);
  58 #elif LIBCXXABI_ARM_EHABI
  59   new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm>(
  60                                  context, LocalAddressSpace::sThisAddressSpace);
  61 #endif
  62   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
  63   co->setInfoBasedOnIPRegister();
  64
  65   return UNW_ESUCCESS;
  66 }
  67
  68 #if UNW_REMOTE
  69
  70 _LIBUNWIND_EXPORT unw_addr_space_t unw_local_addr_space =
  71     (unw_addr_space_t) & sThisAddressSpace;
  72
  73 /// Create a cursor into a thread in another process.
  74 _LIBUNWIND_EXPORT int unw_init_remote_thread(unw_cursor_t *cursor,
  75                                              unw_addr_space_t as,
  76                                              void *arg) {
  77   // special case: unw_init_remote(xx, unw_local_addr_space, xx)
  78   if (as == (unw_addr_space_t) & sThisAddressSpace)
  79     return unw_init_local(cursor, NULL); //FIXME
  80
  81   // use "placement new" to allocate UnwindCursor in the cursor buffer
  82   switch (as->cpuType) {
  83   case CPU_TYPE_I386:
  84     new ((void *)cursor)
  85         UnwindCursor<OtherAddressSpace<Pointer32<LittleEndian> >,
  86                      Registers_x86>(((unw_addr_space_i386 *)as)->oas, arg);
  87     break;
  88   case CPU_TYPE_X86_64:
  89     new ((void *)cursor) UnwindCursor<
  90         OtherAddressSpace<Pointer64<LittleEndian> >, Registers_x86_64>(
  91         ((unw_addr_space_x86_64 *)as)->oas, arg);
  92     break;
  93   case CPU_TYPE_POWERPC:
  94     new ((void *)cursor)
  95         UnwindCursor<OtherAddressSpace<Pointer32<BigEndian> >, Registers_ppc>(
  96             ((unw_addr_space_ppc *)as)->oas, arg);
  97     break;
  98   default:
  99     return UNW_EUNSPEC;
 100   }
 101   return UNW_ESUCCESS;
 102 }
 103
 104
 105 static bool is64bit(task_t task) {
 106   return false; // FIXME
 107 }
 108
 109 /// Create an address_space object for use in examining another task.
 110 _LIBUNWIND_EXPORT unw_addr_space_t unw_create_addr_space_for_task(task_t task) {
 111 #if __i386__
 112   if (is64bit(task)) {
 113     unw_addr_space_x86_64 *as = new unw_addr_space_x86_64(task);
 114     as->taskPort = task;
 115     as->cpuType = CPU_TYPE_X86_64;
 116     //as->oas
 117   } else {
 118     unw_addr_space_i386 *as = new unw_addr_space_i386(task);
 119     as->taskPort = task;
 120     as->cpuType = CPU_TYPE_I386;
 121     //as->oas
 122   }
 123 #else
 124 // FIXME
 125 #endif
 126 }
 127
 128
 129 /// Delete an address_space object.
 130 _LIBUNWIND_EXPORT void unw_destroy_addr_space(unw_addr_space_t asp) {
 131   switch (asp->cpuType) {
 132 #if __i386__ || __x86_64__
 133   case CPU_TYPE_I386: {
 134     unw_addr_space_i386 *as = (unw_addr_space_i386 *)asp;
 135     delete as;
 136   }
 137   break;
 138   case CPU_TYPE_X86_64: {
 139     unw_addr_space_x86_64 *as = (unw_addr_space_x86_64 *)asp;
 140     delete as;
 141   }
 142   break;
 143 #endif
 144   case CPU_TYPE_POWERPC: {
 145     unw_addr_space_ppc *as = (unw_addr_space_ppc *)asp;
 146     delete as;
 147   }
 148   break;
 149   }
 150 }
 151 #endif // UNW_REMOTE
 152
 153
 154 /// Get value of specified register at cursor position in stack frame.
 155 _LIBUNWIND_EXPORT int unw_get_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
 156                                   unw_word_t *value) {
 157   _LIBUNWIND_TRACE_API("unw_get_reg(cursor=%p, regNum=%d, &value=%p)\n",
 158                               cursor, regNum, value);
 159   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 160   if (co->validReg(regNum)) {
 161     *value = co->getReg(regNum);
 162     return UNW_ESUCCESS;
 163   }
 164   return UNW_EBADREG;
 165 }
 166
 167
 168 /// Set value of specified register at cursor position in stack frame.
 169 _LIBUNWIND_EXPORT int unw_set_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
 170                                   unw_word_t value) {
 171   _LIBUNWIND_TRACE_API("unw_set_reg(cursor=%p, regNum=%d, value=0x%llX)\n",
 172                        cursor, regNum, (long long)value);
 173   typedef LocalAddressSpace::pint_t pint_t;
 174   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 175   if (co->validReg(regNum)) {
 176     co->setReg(regNum, (pint_t)value);
 177     // specical case altering IP to re-find info (being called by personality
 178     // function)
 179     if (regNum == UNW_REG_IP)
 180       co->setInfoBasedOnIPRegister(false);
 181     return UNW_ESUCCESS;
 182   }
 183   return UNW_EBADREG;
 184 }
 185
 186
 187 /// Get value of specified float register at cursor position in stack frame.
 188 _LIBUNWIND_EXPORT int unw_get_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
 189                                     unw_fpreg_t *value) {
 190   _LIBUNWIND_TRACE_API("unw_get_fpreg(cursor=%p, regNum=%d, &value=%p)\n",
 191                              cursor, regNum, value);
 192   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 193   if (co->validFloatReg(regNum)) {
 194     *value = co->getFloatReg(regNum);
 195     return UNW_ESUCCESS;
 196   }
 197   return UNW_EBADREG;
 198 }
 199
 200
 201 /// Set value of specified float register at cursor position in stack frame.
 202 _LIBUNWIND_EXPORT int unw_set_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
 203                                     unw_fpreg_t value) {
 204 #if LIBCXXABI_ARM_EHABI
 205   _LIBUNWIND_TRACE_API("unw_set_fpreg(cursor=%p, regNum=%d, value=%llX)\n",
 206                        cursor, regNum, value);
 207 #else
 208   _LIBUNWIND_TRACE_API("unw_set_fpreg(cursor=%p, regNum=%d, value=%g)\n",
 209                        cursor, regNum, value);
 210 #endif
 211   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 212   if (co->validFloatReg(regNum)) {
 213     co->setFloatReg(regNum, value);
 214     return UNW_ESUCCESS;
 215   }
 216   return UNW_EBADREG;
 217 }
 218
 219
 220 /// Move cursor to next frame.
 221 _LIBUNWIND_EXPORT int unw_step(unw_cursor_t *cursor) {
 222   _LIBUNWIND_TRACE_API("unw_step(cursor=%p)\n", cursor);
 223   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 224   return co->step();
 225 }
 226
 227
 228 /// Get unwind info at cursor position in stack frame.
 229 _LIBUNWIND_EXPORT int unw_get_proc_info(unw_cursor_t *cursor,
 230                                         unw_proc_info_t *info) {
 231   _LIBUNWIND_TRACE_API("unw_get_proc_info(cursor=%p, &info=%p)\n",
 232                              cursor, info);
 233   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 234   co->getInfo(info);
 235   if (info->end_ip == 0)
 236     return UNW_ENOINFO;
 237   else
 238     return UNW_ESUCCESS;
 239 }
 240
 241
 242 /// Resume execution at cursor position (aka longjump).
 243 _LIBUNWIND_EXPORT int unw_resume(unw_cursor_t *cursor) {
 244   _LIBUNWIND_TRACE_API("unw_resume(cursor=%p)\n", cursor);
 245   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 246   co->jumpto();
 247   return UNW_EUNSPEC;
 248 }
 249
 250
 251 /// Get name of function at cursor position in stack frame.
 252 _LIBUNWIND_EXPORT int unw_get_proc_name(unw_cursor_t *cursor, char *buf,
 253                                         size_t bufLen, unw_word_t *offset) {
 254   _LIBUNWIND_TRACE_API("unw_get_proc_name(cursor=%p, &buf=%p,"
 255                              "bufLen=%zu)\n", cursor, buf, bufLen);
 256   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 257   if (co->getFunctionName(buf, bufLen, offset))
 258     return UNW_ESUCCESS;
 259   else
 260     return UNW_EUNSPEC;
 261 }
 262
 263
 264 /// Checks if a register is a floating-point register.
 265 _LIBUNWIND_EXPORT int unw_is_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum) {
 266   _LIBUNWIND_TRACE_API("unw_is_fpreg(cursor=%p, regNum=%d)\n",
 267                              cursor, regNum);
 268   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 269   return co->validFloatReg(regNum);
 270 }
 271
 272
 273 /// Checks if a register is a floating-point register.
 274 _LIBUNWIND_EXPORT const char *unw_regname(unw_cursor_t *cursor,
 275                                           unw_regnum_t regNum) {
 276   _LIBUNWIND_TRACE_API("unw_regname(cursor=%p, regNum=%d)\n",
 277                              cursor, regNum);
 278   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 279   return co->getRegisterName(regNum);
 280 }
 281
 282
 283 /// Checks if current frame is signal trampoline.
 284 _LIBUNWIND_EXPORT int unw_is_signal_frame(unw_cursor_t *cursor) {
 285   _LIBUNWIND_TRACE_API("unw_is_signal_frame(cursor=%p)\n", cursor);
 286   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 287   return co->isSignalFrame();
 288 }
 289
 290 #if __arm__
 291 // Save VFP registers d0-d15 using FSTMIADX instead of FSTMIADD
 292 _LIBUNWIND_EXPORT void unw_save_vfp_as_X(unw_cursor_t *cursor) {
 293   _LIBUNWIND_TRACE_API("unw_fpreg_save_vfp_as_X(cursor=%p)\n", cursor);
 294   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
 295   return co->saveVFPAsX();
 296 }
 297 #endif
 298
 299
 300 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
 301 /// SPI: walks cached dwarf entries
 302 _LIBUNWIND_EXPORT void unw_iterate_dwarf_unwind_cache(void (*func)(
 303     unw_word_t ip_start, unw_word_t ip_end, unw_word_t fde, unw_word_t mh)) {
 304   _LIBUNWIND_TRACE_API("unw_iterate_dwarf_unwind_cache(func=%p)\n", func);
 305   DwarfFDECache<LocalAddressSpace>::iterateCacheEntries(func);
 306 }
 307
 308
 309 /// IPI: for __register_frame()
 310 void _unw_add_dynamic_fde(unw_word_t fde) {
 311   CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
 312   CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
 313   const char *message = CFI_Parser<LocalAddressSpace>::decodeFDE(
 314                            LocalAddressSpace::sThisAddressSpace,
 315                           (LocalAddressSpace::pint_t) fde, &fdeInfo, &cieInfo);
 316   if (message == NULL) {
 317     // dynamically registered FDEs don't have a mach_header group they are in.
 318     // Use fde as mh_group
 319     unw_word_t mh_group = fdeInfo.fdeStart;
 320     DwarfFDECache<LocalAddressSpace>::add((LocalAddressSpace::pint_t)mh_group,
 321                                           fdeInfo.pcStart, fdeInfo.pcEnd,
 322                                           fdeInfo.fdeStart);
 323   } else {
 324     _LIBUNWIND_DEBUG_LOG("_unw_add_dynamic_fde: bad fde: %s", message);
 325   }
 326 }
 327
 328 /// IPI: for __deregister_frame()
 329 void _unw_remove_dynamic_fde(unw_word_t fde) {
 330   // fde is own mh_group
 331   DwarfFDECache<LocalAddressSpace>::removeAllIn((LocalAddressSpace::pint_t)fde);
 332 }
 333 #endif // _LIBUNWIND_SUPPORT_DWARF_UNWIND
 334
 335 #endif // _LIBUNWIND_BUILD_ZERO_COST_APIS
 336
 337
 338
 339 // Add logging hooks in Debug builds only
 340 #ifndef NDEBUG
 341 #include <stdlib.h>
 342
 343 _LIBUNWIND_HIDDEN
 344 bool logAPIs() {
 345   // do manual lock to avoid use of _cxa_guard_acquire or initializers
 346   static bool checked = false;
 347   static bool log = false;
 348   if (!checked) {
 349     log = (getenv("LIBUNWIND_PRINT_APIS") != NULL);
 350     checked = true;
 351   }
 352   return log;
 353 }
 354
 355 _LIBUNWIND_HIDDEN
 356 bool logUnwinding() {
 357   // do manual lock to avoid use of _cxa_guard_acquire or initializers
 358   static bool checked = false;
 359   static bool log = false;
 360   if (!checked) {
 361     log = (getenv("LIBUNWIND_PRINT_UNWINDING") != NULL);
 362     checked = true;
 363   }
 364   return log;
 365 }
 366
 367 #endif // NDEBUG
 368