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