contrib/libunwind/src/Unwind-EHABI.cpp

   1 //===--------------------------- Unwind-EHABI.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 ARM zero-cost C++ exceptions
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "Unwind-EHABI.h"
  14
  15 #if defined(_LIBUNWIND_ARM_EHABI)
  16
  17 #include <inttypes.h>
  18 #include <stdbool.h>
  19 #include <stdint.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include <type_traits>
  25
  26 #include "config.h"
  27 #include "libunwind.h"
  28 #include "libunwind_ext.h"
  29 #include "unwind.h"
  30
  31 namespace {
  32
  33 // Strange order: take words in order, but inside word, take from most to least
  34 // signinficant byte.
  35 uint8_t getByte(const uint32_t* data, size_t offset) {
  36   const uint8_t* byteData = reinterpret_cast<const uint8_t*>(data);
  37   return byteData[(offset & ~(size_t)0x03) + (3 - (offset & (size_t)0x03))];
  38 }
  39
  40 const char* getNextWord(const char* data, uint32_t* out) {
  41   *out = *reinterpret_cast<const uint32_t*>(data);
  42   return data + 4;
  43 }
  44
  45 const char* getNextNibble(const char* data, uint32_t* out) {
  46   *out = *reinterpret_cast<const uint16_t*>(data);
  47   return data + 2;
  48 }
  49
  50 struct Descriptor {
  51   // See # 9.2
  52   typedef enum {
  53     SU16 = 0, // Short descriptor, 16-bit entries
  54     LU16 = 1, // Long descriptor,  16-bit entries
  55     LU32 = 3, // Long descriptor,  32-bit entries
  56     RESERVED0 =  4, RESERVED1 =  5, RESERVED2  = 6,  RESERVED3  =  7,
  57     RESERVED4 =  8, RESERVED5 =  9, RESERVED6  = 10, RESERVED7  = 11,
  58     RESERVED8 = 12, RESERVED9 = 13, RESERVED10 = 14, RESERVED11 = 15
  59   } Format;
  60
  61   // See # 9.2
  62   typedef enum {
  63     CLEANUP = 0x0,
  64     FUNC    = 0x1,
  65     CATCH   = 0x2,
  66     INVALID = 0x4
  67   } Kind;
  68 };
  69
  70 _Unwind_Reason_Code ProcessDescriptors(
  71     _Unwind_State state,
  72     _Unwind_Control_Block* ucbp,
  73     struct _Unwind_Context* context,
  74     Descriptor::Format format,
  75     const char* descriptorStart,
  76     uint32_t flags) {
  77
  78   // EHT is inlined in the index using compact form. No descriptors. #5
  79   if (flags & 0x1)
  80     return _URC_CONTINUE_UNWIND;
  81
  82   // TODO: We should check the state here, and determine whether we need to
  83   // perform phase1 or phase2 unwinding.
  84   (void)state;
  85
  86   const char* descriptor = descriptorStart;
  87   uint32_t descriptorWord;
  88   getNextWord(descriptor, &descriptorWord);
  89   while (descriptorWord) {
  90     // Read descriptor based on # 9.2.
  91     uint32_t length;
  92     uint32_t offset;
  93     switch (format) {
  94       case Descriptor::LU32:
  95         descriptor = getNextWord(descriptor, &length);
  96         descriptor = getNextWord(descriptor, &offset);
  97       case Descriptor::LU16:
  98         descriptor = getNextNibble(descriptor, &length);
  99         descriptor = getNextNibble(descriptor, &offset);
 100       default:
 101         assert(false);
 102         return _URC_FAILURE;
 103     }
 104
 105     // See # 9.2 table for decoding the kind of descriptor. It's a 2-bit value.
 106     Descriptor::Kind kind =
 107         static_cast<Descriptor::Kind>((length & 0x1) | ((offset & 0x1) << 1));
 108
 109     // Clear off flag from last bit.
 110     length &= ~1u;
 111     offset &= ~1u;
 112     uintptr_t scopeStart = ucbp->pr_cache.fnstart + offset;
 113     uintptr_t scopeEnd = scopeStart + length;
 114     uintptr_t pc = _Unwind_GetIP(context);
 115     bool isInScope = (scopeStart <= pc) && (pc < scopeEnd);
 116
 117     switch (kind) {
 118       case Descriptor::CLEANUP: {
 119         // TODO(ajwong): Handle cleanup descriptors.
 120         break;
 121       }
 122       case Descriptor::FUNC: {
 123         // TODO(ajwong): Handle function descriptors.
 124         break;
 125       }
 126       case Descriptor::CATCH: {
 127         // Catch descriptors require gobbling one more word.
 128         uint32_t landing_pad;
 129         descriptor = getNextWord(descriptor, &landing_pad);
 130
 131         if (isInScope) {
 132           // TODO(ajwong): This is only phase1 compatible logic. Implement
 133           // phase2.
 134           landing_pad = signExtendPrel31(landing_pad & ~0x80000000);
 135           if (landing_pad == 0xffffffff) {
 136             return _URC_HANDLER_FOUND;
 137           } else if (landing_pad == 0xfffffffe) {
 138             return _URC_FAILURE;
 139           } else {
 140             /*
 141             bool is_reference_type = landing_pad & 0x80000000;
 142             void* matched_object;
 143             if (__cxxabiv1::__cxa_type_match(
 144                     ucbp, reinterpret_cast<const std::type_info *>(landing_pad),
 145                     is_reference_type,
 146                     &matched_object) != __cxxabiv1::ctm_failed)
 147                 return _URC_HANDLER_FOUND;
 148                 */
 149             _LIBUNWIND_ABORT("Type matching not implemented");
 150           }
 151         }
 152         break;
 153       }
 154       default:
 155         _LIBUNWIND_ABORT("Invalid descriptor kind found.");
 156     }
 157
 158     getNextWord(descriptor, &descriptorWord);
 159   }
 160
 161   return _URC_CONTINUE_UNWIND;
 162 }
 163
 164 static _Unwind_Reason_Code unwindOneFrame(_Unwind_State state,
 165                                           _Unwind_Control_Block* ucbp,
 166                                           struct _Unwind_Context* context) {
 167   // Read the compact model EHT entry's header # 6.3
 168   const uint32_t* unwindingData = ucbp->pr_cache.ehtp;
 169   assert((*unwindingData & 0xf0000000) == 0x80000000 && "Must be a compact entry");
 170   Descriptor::Format format =
 171       static_cast<Descriptor::Format>((*unwindingData & 0x0f000000) >> 24);
 172
 173   const char *lsda =
 174       reinterpret_cast<const char *>(_Unwind_GetLanguageSpecificData(context));
 175
 176   // Handle descriptors before unwinding so they are processed in the context
 177   // of the correct stack frame.
 178   _Unwind_Reason_Code result =
 179       ProcessDescriptors(state, ucbp, context, format, lsda,
 180                          ucbp->pr_cache.additional);
 181
 182   if (result != _URC_CONTINUE_UNWIND)
 183     return result;
 184
 185   if (unw_step(reinterpret_cast<unw_cursor_t*>(context)) != UNW_STEP_SUCCESS)
 186     return _URC_FAILURE;
 187   return _URC_CONTINUE_UNWIND;
 188 }
 189
 190 // Generates mask discriminator for _Unwind_VRS_Pop, e.g. for _UVRSC_CORE /
 191 // _UVRSD_UINT32.
 192 uint32_t RegisterMask(uint8_t start, uint8_t count_minus_one) {
 193   return ((1U << (count_minus_one + 1)) - 1) << start;
 194 }
 195
 196 // Generates mask discriminator for _Unwind_VRS_Pop, e.g. for _UVRSC_VFP /
 197 // _UVRSD_DOUBLE.
 198 uint32_t RegisterRange(uint8_t start, uint8_t count_minus_one) {
 199   return ((uint32_t)start << 16) | ((uint32_t)count_minus_one + 1);
 200 }
 201
 202 } // end anonymous namespace
 203
 204 /**
 205  * Decodes an EHT entry.
 206  *
 207  * @param data Pointer to EHT.
 208  * @param[out] off Offset from return value (in bytes) to begin interpretation.
 209  * @param[out] len Number of bytes in unwind code.
 210  * @return Pointer to beginning of unwind code.
 211  */
 212 extern "C" const uint32_t*
 213 decode_eht_entry(const uint32_t* data, size_t* off, size_t* len) {
 214   if ((*data & 0x80000000) == 0) {
 215     // 6.2: Generic Model
 216     //
 217     // EHT entry is a prel31 pointing to the PR, followed by data understood
 218     // only by the personality routine. Fortunately, all existing assembler
 219     // implementations, including GNU assembler, LLVM integrated assembler,
 220     // and ARM assembler, assume that the unwind opcodes come after the
 221     // personality rountine address.
 222     *off = 1; // First byte is size data.
 223     *len = (((data[1] >> 24) & 0xff) + 1) * 4;
 224     data++; // Skip the first word, which is the prel31 offset.
 225   } else {
 226     // 6.3: ARM Compact Model
 227     //
 228     // EHT entries here correspond to the __aeabi_unwind_cpp_pr[012] PRs indeded
 229     // by format:
 230     Descriptor::Format format =
 231         static_cast<Descriptor::Format>((*data & 0x0f000000) >> 24);
 232     switch (format) {
 233       case Descriptor::SU16:
 234         *len = 4;
 235         *off = 1;
 236         break;
 237       case Descriptor::LU16:
 238       case Descriptor::LU32:
 239         *len = 4 + 4 * ((*data & 0x00ff0000) >> 16);
 240         *off = 2;
 241         break;
 242       default:
 243         return nullptr;
 244     }
 245   }
 246   return data;
 247 }
 248
 249 _LIBUNWIND_EXPORT _Unwind_Reason_Code
 250 _Unwind_VRS_Interpret(_Unwind_Context *context, const uint32_t *data,
 251                       size_t offset, size_t len) {
 252   bool wrotePC = false;
 253   bool finish = false;
 254   while (offset < len && !finish) {
 255     uint8_t byte = getByte(data, offset++);
 256     if ((byte & 0x80) == 0) {
 257       uint32_t sp;
 258       _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
 259       if (byte & 0x40)
 260         sp -= (((uint32_t)byte & 0x3f) << 2) + 4;
 261       else
 262         sp += ((uint32_t)byte << 2) + 4;
 263       _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32, &sp);
 264     } else {
 265       switch (byte & 0xf0) {
 266         case 0x80: {
 267           if (offset >= len)
 268             return _URC_FAILURE;
 269           uint32_t registers =
 270               (((uint32_t)byte & 0x0f) << 12) |
 271               (((uint32_t)getByte(data, offset++)) << 4);
 272           if (!registers)
 273             return _URC_FAILURE;
 274           if (registers & (1 << 15))
 275             wrotePC = true;
 276           _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
 277           break;
 278         }
 279         case 0x90: {
 280           uint8_t reg = byte & 0x0f;
 281           if (reg == 13 || reg == 15)
 282             return _URC_FAILURE;
 283           uint32_t sp;
 284           _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_R0 + reg,
 285                           _UVRSD_UINT32, &sp);
 286           _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
 287                           &sp);
 288           break;
 289         }
 290         case 0xa0: {
 291           uint32_t registers = RegisterMask(4, byte & 0x07);
 292           if (byte & 0x08)
 293             registers |= 1 << 14;
 294           _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
 295           break;
 296         }
 297         case 0xb0: {
 298           switch (byte) {
 299             case 0xb0:
 300               finish = true;
 301               break;
 302             case 0xb1: {
 303               if (offset >= len)
 304                 return _URC_FAILURE;
 305               uint8_t registers = getByte(data, offset++);
 306               if (registers & 0xf0 || !registers)
 307                 return _URC_FAILURE;
 308               _Unwind_VRS_Pop(context, _UVRSC_CORE, registers, _UVRSD_UINT32);
 309               break;
 310             }
 311             case 0xb2: {
 312               uint32_t addend = 0;
 313               uint32_t shift = 0;
 314               // This decodes a uleb128 value.
 315               while (true) {
 316                 if (offset >= len)
 317                   return _URC_FAILURE;
 318                 uint32_t v = getByte(data, offset++);
 319                 addend |= (v & 0x7f) << shift;
 320                 if ((v & 0x80) == 0)
 321                   break;
 322                 shift += 7;
 323               }
 324               uint32_t sp;
 325               _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
 326                               &sp);
 327               sp += 0x204 + (addend << 2);
 328               _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
 329                               &sp);
 330               break;
 331             }
 332             case 0xb3: {
 333               uint8_t v = getByte(data, offset++);
 334               _Unwind_VRS_Pop(context, _UVRSC_VFP,
 335                               RegisterRange(static_cast<uint8_t>(v >> 4),
 336                                             v & 0x0f), _UVRSD_VFPX);
 337               break;
 338             }
 339             case 0xb4:
 340             case 0xb5:
 341             case 0xb6:
 342             case 0xb7:
 343               return _URC_FAILURE;
 344             default:
 345               _Unwind_VRS_Pop(context, _UVRSC_VFP,
 346                               RegisterRange(8, byte & 0x07), _UVRSD_VFPX);
 347               break;
 348           }
 349           break;
 350         }
 351         case 0xc0: {
 352           switch (byte) {
 353 #if defined(__ARM_WMMX)
 354             case 0xc0:
 355             case 0xc1:
 356             case 0xc2:
 357             case 0xc3:
 358             case 0xc4:
 359             case 0xc5:
 360               _Unwind_VRS_Pop(context, _UVRSC_WMMXD,
 361                               RegisterRange(10, byte & 0x7), _UVRSD_DOUBLE);
 362               break;
 363             case 0xc6: {
 364               uint8_t v = getByte(data, offset++);
 365               uint8_t start = static_cast<uint8_t>(v >> 4);
 366               uint8_t count_minus_one = v & 0xf;
 367               if (start + count_minus_one >= 16)
 368                 return _URC_FAILURE;
 369               _Unwind_VRS_Pop(context, _UVRSC_WMMXD,
 370                               RegisterRange(start, count_minus_one),
 371                               _UVRSD_DOUBLE);
 372               break;
 373             }
 374             case 0xc7: {
 375               uint8_t v = getByte(data, offset++);
 376               if (!v || v & 0xf0)
 377                 return _URC_FAILURE;
 378               _Unwind_VRS_Pop(context, _UVRSC_WMMXC, v, _UVRSD_DOUBLE);
 379               break;
 380             }
 381 #endif
 382             case 0xc8:
 383             case 0xc9: {
 384               uint8_t v = getByte(data, offset++);
 385               uint8_t start =
 386                   static_cast<uint8_t>(((byte == 0xc8) ? 16 : 0) + (v >> 4));
 387               uint8_t count_minus_one = v & 0xf;
 388               if (start + count_minus_one >= 32)
 389                 return _URC_FAILURE;
 390               _Unwind_VRS_Pop(context, _UVRSC_VFP,
 391                               RegisterRange(start, count_minus_one),
 392                               _UVRSD_DOUBLE);
 393               break;
 394             }
 395             default:
 396               return _URC_FAILURE;
 397           }
 398           break;
 399         }
 400         case 0xd0: {
 401           if (byte & 0x08)
 402             return _URC_FAILURE;
 403           _Unwind_VRS_Pop(context, _UVRSC_VFP, RegisterRange(8, byte & 0x7),
 404                           _UVRSD_DOUBLE);
 405           break;
 406         }
 407         default:
 408           return _URC_FAILURE;
 409       }
 410     }
 411   }
 412   if (!wrotePC) {
 413     uint32_t lr;
 414     _Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_LR, _UVRSD_UINT32, &lr);
 415     _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_IP, _UVRSD_UINT32, &lr);
 416   }
 417   return _URC_CONTINUE_UNWIND;
 418 }
 419
 420 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
 421 __aeabi_unwind_cpp_pr0(_Unwind_State state, _Unwind_Control_Block *ucbp,
 422                        _Unwind_Context *context) {
 423   return unwindOneFrame(state, ucbp, context);
 424 }
 425
 426 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
 427 __aeabi_unwind_cpp_pr1(_Unwind_State state, _Unwind_Control_Block *ucbp,
 428                        _Unwind_Context *context) {
 429   return unwindOneFrame(state, ucbp, context);
 430 }
 431
 432 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
 433 __aeabi_unwind_cpp_pr2(_Unwind_State state, _Unwind_Control_Block *ucbp,
 434                        _Unwind_Context *context) {
 435   return unwindOneFrame(state, ucbp, context);
 436 }
 437
 438 static _Unwind_Reason_Code
 439 unwind_phase1(unw_context_t *uc, unw_cursor_t *cursor, _Unwind_Exception *exception_object) {
 440   // EHABI #7.3 discusses preserving the VRS in a "temporary VRS" during
 441   // phase 1 and then restoring it to the "primary VRS" for phase 2. The
 442   // effect is phase 2 doesn't see any of the VRS manipulations from phase 1.
 443   // In this implementation, the phases don't share the VRS backing store.
 444   // Instead, they are passed the original |uc| and they create a new VRS
 445   // from scratch thus achieving the same effect.
 446   unw_init_local(cursor, uc);
 447
 448   // Walk each frame looking for a place to stop.
 449   for (bool handlerNotFound = true; handlerNotFound;) {
 450
 451     // See if frame has code to run (has personality routine).
 452     unw_proc_info_t frameInfo;
 453     if (unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
 454       _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): unw_get_proc_info "
 455                                  "failed => _URC_FATAL_PHASE1_ERROR",
 456                                  static_cast<void *>(exception_object));
 457       return _URC_FATAL_PHASE1_ERROR;
 458     }
 459
 460     // When tracing, print state information.
 461     if (_LIBUNWIND_TRACING_UNWINDING) {
 462       char functionBuf[512];
 463       const char *functionName = functionBuf;
 464       unw_word_t offset;
 465       if ((unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
 466                              &offset) != UNW_ESUCCESS) ||
 467           (frameInfo.start_ip + offset > frameInfo.end_ip))
 468         functionName = ".anonymous.";
 469       unw_word_t pc;
 470       unw_get_reg(cursor, UNW_REG_IP, &pc);
 471       _LIBUNWIND_TRACE_UNWINDING(
 472           "unwind_phase1(ex_ojb=%p): pc=0x%" PRIxPTR ", start_ip=0x%" PRIxPTR ", func=%s, "
 473           "lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR,
 474           static_cast<void *>(exception_object), pc,
 475           frameInfo.start_ip, functionName,
 476           frameInfo.lsda, frameInfo.handler);
 477     }
 478
 479     // If there is a personality routine, ask it if it will want to stop at
 480     // this frame.
 481     if (frameInfo.handler != 0) {
 482       __personality_routine p =
 483           (__personality_routine)(long)(frameInfo.handler);
 484       _LIBUNWIND_TRACE_UNWINDING(
 485           "unwind_phase1(ex_ojb=%p): calling personality function %p",
 486           static_cast<void *>(exception_object),
 487           reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(p)));
 488       struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
 489       exception_object->pr_cache.fnstart = frameInfo.start_ip;
 490       exception_object->pr_cache.ehtp =
 491           (_Unwind_EHT_Header *)frameInfo.unwind_info;
 492       exception_object->pr_cache.additional = frameInfo.flags;
 493       _Unwind_Reason_Code personalityResult =
 494           (*p)(_US_VIRTUAL_UNWIND_FRAME, exception_object, context);
 495       _LIBUNWIND_TRACE_UNWINDING(
 496           "unwind_phase1(ex_ojb=%p): personality result %d start_ip %x ehtp %p "
 497           "additional %x",
 498           static_cast<void *>(exception_object), personalityResult,
 499           exception_object->pr_cache.fnstart,
 500           static_cast<void *>(exception_object->pr_cache.ehtp),
 501           exception_object->pr_cache.additional);
 502       switch (personalityResult) {
 503       case _URC_HANDLER_FOUND:
 504         // found a catch clause or locals that need destructing in this frame
 505         // stop search and remember stack pointer at the frame
 506         handlerNotFound = false;
 507         // p should have initialized barrier_cache. EHABI #7.3.5
 508         _LIBUNWIND_TRACE_UNWINDING(
 509             "unwind_phase1(ex_ojb=%p): _URC_HANDLER_FOUND",
 510             static_cast<void *>(exception_object));
 511         return _URC_NO_REASON;
 512
 513       case _URC_CONTINUE_UNWIND:
 514         _LIBUNWIND_TRACE_UNWINDING(
 515             "unwind_phase1(ex_ojb=%p): _URC_CONTINUE_UNWIND",
 516             static_cast<void *>(exception_object));
 517         // continue unwinding
 518         break;
 519
 520       // EHABI #7.3.3
 521       case _URC_FAILURE:
 522         return _URC_FAILURE;
 523
 524       default:
 525         // something went wrong
 526         _LIBUNWIND_TRACE_UNWINDING(
 527             "unwind_phase1(ex_ojb=%p): _URC_FATAL_PHASE1_ERROR",
 528             static_cast<void *>(exception_object));
 529         return _URC_FATAL_PHASE1_ERROR;
 530       }
 531     }
 532   }
 533   return _URC_NO_REASON;
 534 }
 535
 536 static _Unwind_Reason_Code unwind_phase2(unw_context_t *uc, unw_cursor_t *cursor,
 537                                          _Unwind_Exception *exception_object,
 538                                          bool resume) {
 539   // See comment at the start of unwind_phase1 regarding VRS integrity.
 540   unw_init_local(cursor, uc);
 541
 542   _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p)",
 543                              static_cast<void *>(exception_object));
 544   int frame_count = 0;
 545
 546   // Walk each frame until we reach where search phase said to stop.
 547   while (true) {
 548     // Ask libunwind to get next frame (skip over first which is
 549     // _Unwind_RaiseException or _Unwind_Resume).
 550     //
 551     // Resume only ever makes sense for 1 frame.
 552     _Unwind_State state =
 553         resume ? _US_UNWIND_FRAME_RESUME : _US_UNWIND_FRAME_STARTING;
 554     if (resume && frame_count == 1) {
 555       // On a resume, first unwind the _Unwind_Resume() frame. The next frame
 556       // is now the landing pad for the cleanup from a previous execution of
 557       // phase2. To continue unwindingly correctly, replace VRS[15] with the
 558       // IP of the frame that the previous run of phase2 installed the context
 559       // for. After this, continue unwinding as if normal.
 560       //
 561       // See #7.4.6 for details.
 562       unw_set_reg(cursor, UNW_REG_IP,
 563                   exception_object->unwinder_cache.reserved2);
 564       resume = false;
 565     }
 566
 567     // Get info about this frame.
 568     unw_word_t sp;
 569     unw_proc_info_t frameInfo;
 570     unw_get_reg(cursor, UNW_REG_SP, &sp);
 571     if (unw_get_proc_info(cursor, &frameInfo) != UNW_ESUCCESS) {
 572       _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): unw_get_proc_info "
 573                                  "failed => _URC_FATAL_PHASE2_ERROR",
 574                                  static_cast<void *>(exception_object));
 575       return _URC_FATAL_PHASE2_ERROR;
 576     }
 577
 578     // When tracing, print state information.
 579     if (_LIBUNWIND_TRACING_UNWINDING) {
 580       char functionBuf[512];
 581       const char *functionName = functionBuf;
 582       unw_word_t offset;
 583       if ((unw_get_proc_name(cursor, functionBuf, sizeof(functionBuf),
 584                              &offset) != UNW_ESUCCESS) ||
 585           (frameInfo.start_ip + offset > frameInfo.end_ip))
 586         functionName = ".anonymous.";
 587       _LIBUNWIND_TRACE_UNWINDING(
 588           "unwind_phase2(ex_ojb=%p): start_ip=0x%" PRIxPTR ", func=%s, sp=0x%" PRIxPTR ", "
 589           "lsda=0x%" PRIxPTR ", personality=0x%" PRIxPTR "",
 590           static_cast<void *>(exception_object), frameInfo.start_ip,
 591           functionName, sp, frameInfo.lsda,
 592           frameInfo.handler);
 593     }
 594
 595     // If there is a personality routine, tell it we are unwinding.
 596     if (frameInfo.handler != 0) {
 597       __personality_routine p =
 598           (__personality_routine)(long)(frameInfo.handler);
 599       struct _Unwind_Context *context = (struct _Unwind_Context *)(cursor);
 600       // EHABI #7.2
 601       exception_object->pr_cache.fnstart = frameInfo.start_ip;
 602       exception_object->pr_cache.ehtp =
 603           (_Unwind_EHT_Header *)frameInfo.unwind_info;
 604       exception_object->pr_cache.additional = frameInfo.flags;
 605       _Unwind_Reason_Code personalityResult =
 606           (*p)(state, exception_object, context);
 607       switch (personalityResult) {
 608       case _URC_CONTINUE_UNWIND:
 609         // Continue unwinding
 610         _LIBUNWIND_TRACE_UNWINDING(
 611             "unwind_phase2(ex_ojb=%p): _URC_CONTINUE_UNWIND",
 612             static_cast<void *>(exception_object));
 613         // EHABI #7.2
 614         if (sp == exception_object->barrier_cache.sp) {
 615           // Phase 1 said we would stop at this frame, but we did not...
 616           _LIBUNWIND_ABORT("during phase1 personality function said it would "
 617                            "stop here, but now in phase2 it did not stop here");
 618         }
 619         break;
 620       case _URC_INSTALL_CONTEXT:
 621         _LIBUNWIND_TRACE_UNWINDING(
 622             "unwind_phase2(ex_ojb=%p): _URC_INSTALL_CONTEXT",
 623             static_cast<void *>(exception_object));
 624         // Personality routine says to transfer control to landing pad.
 625         // We may get control back if landing pad calls _Unwind_Resume().
 626         if (_LIBUNWIND_TRACING_UNWINDING) {
 627           unw_word_t pc;
 628           unw_get_reg(cursor, UNW_REG_IP, &pc);
 629           unw_get_reg(cursor, UNW_REG_SP, &sp);
 630           _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): re-entering "
 631                                      "user code with ip=0x%" PRIxPTR ", sp=0x%" PRIxPTR,
 632                                      static_cast<void *>(exception_object),
 633                                      pc, sp);
 634         }
 635
 636         {
 637           // EHABI #7.4.1 says we need to preserve pc for when _Unwind_Resume
 638           // is called back, to find this same frame.
 639           unw_word_t pc;
 640           unw_get_reg(cursor, UNW_REG_IP, &pc);
 641           exception_object->unwinder_cache.reserved2 = (uint32_t)pc;
 642         }
 643         unw_resume(cursor);
 644         // unw_resume() only returns if there was an error.
 645         return _URC_FATAL_PHASE2_ERROR;
 646
 647       // # EHABI #7.4.3
 648       case _URC_FAILURE:
 649         abort();
 650
 651       default:
 652         // Personality routine returned an unknown result code.
 653         _LIBUNWIND_DEBUG_LOG("personality function returned unknown result %d",
 654                       personalityResult);
 655         return _URC_FATAL_PHASE2_ERROR;
 656       }
 657     }
 658     frame_count++;
 659   }
 660
 661   // Clean up phase did not resume at the frame that the search phase
 662   // said it would...
 663   return _URC_FATAL_PHASE2_ERROR;
 664 }
 665
 666 /// Called by __cxa_throw.  Only returns if there is a fatal error.
 667 _LIBUNWIND_EXPORT _Unwind_Reason_Code
 668 _Unwind_RaiseException(_Unwind_Exception *exception_object) {
 669   _LIBUNWIND_TRACE_API("_Unwind_RaiseException(ex_obj=%p)",
 670                        static_cast<void *>(exception_object));
 671   unw_context_t uc;
 672   unw_cursor_t cursor;
 673   unw_getcontext(&uc);
 674
 675   // This field for is for compatibility with GCC to say this isn't a forced
 676   // unwind. EHABI #7.2
 677   exception_object->unwinder_cache.reserved1 = 0;
 678
 679   // phase 1: the search phase
 680   _Unwind_Reason_Code phase1 = unwind_phase1(&uc, &cursor, exception_object);
 681   if (phase1 != _URC_NO_REASON)
 682     return phase1;
 683
 684   // phase 2: the clean up phase
 685   return unwind_phase2(&uc, &cursor, exception_object, false);
 686 }
 687
 688 _LIBUNWIND_EXPORT void _Unwind_Complete(_Unwind_Exception* exception_object) {
 689   // This is to be called when exception handling completes to give us a chance
 690   // to perform any housekeeping. EHABI #7.2. But we have nothing to do here.
 691   (void)exception_object;
 692 }
 693
 694 /// When _Unwind_RaiseException() is in phase2, it hands control
 695 /// to the personality function at each frame.  The personality
 696 /// may force a jump to a landing pad in that function, the landing
 697 /// pad code may then call _Unwind_Resume() to continue with the
 698 /// unwinding.  Note: the call to _Unwind_Resume() is from compiler
 699 /// geneated user code.  All other _Unwind_* routines are called
 700 /// by the C++ runtime __cxa_* routines.
 701 ///
 702 /// Note: re-throwing an exception (as opposed to continuing the unwind)
 703 /// is implemented by having the code call __cxa_rethrow() which
 704 /// in turn calls _Unwind_Resume_or_Rethrow().
 705 _LIBUNWIND_EXPORT void
 706 _Unwind_Resume(_Unwind_Exception *exception_object) {
 707   _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)",
 708                        static_cast<void *>(exception_object));
 709   unw_context_t uc;
 710   unw_cursor_t cursor;
 711   unw_getcontext(&uc);
 712
 713   // _Unwind_RaiseException on EHABI will always set the reserved1 field to 0,
 714   // which is in the same position as private_1 below.
 715   // TODO(ajwong): Who wronte the above? Why is it true?
 716   unwind_phase2(&uc, &cursor, exception_object, true);
 717
 718   // Clients assume _Unwind_Resume() does not return, so all we can do is abort.
 719   _LIBUNWIND_ABORT("_Unwind_Resume() can't return");
 720 }
 721
 722 /// Called by personality handler during phase 2 to get LSDA for current frame.
 723 _LIBUNWIND_EXPORT uintptr_t
 724 _Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {
 725   unw_cursor_t *cursor = (unw_cursor_t *)context;
 726   unw_proc_info_t frameInfo;
 727   uintptr_t result = 0;
 728   if (unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
 729     result = (uintptr_t)frameInfo.lsda;
 730   _LIBUNWIND_TRACE_API(
 731       "_Unwind_GetLanguageSpecificData(context=%p) => 0x%llx",
 732       static_cast<void *>(context), (long long)result);
 733   return result;
 734 }
 735
 736 static uint64_t ValueAsBitPattern(_Unwind_VRS_DataRepresentation representation,
 737                                   void* valuep) {
 738   uint64_t value = 0;
 739   switch (representation) {
 740     case _UVRSD_UINT32:
 741     case _UVRSD_FLOAT:
 742       memcpy(&value, valuep, sizeof(uint32_t));
 743       break;
 744
 745     case _UVRSD_VFPX:
 746     case _UVRSD_UINT64:
 747     case _UVRSD_DOUBLE:
 748       memcpy(&value, valuep, sizeof(uint64_t));
 749       break;
 750   }
 751   return value;
 752 }
 753
 754 _LIBUNWIND_EXPORT _Unwind_VRS_Result
 755 _Unwind_VRS_Set(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
 756                 uint32_t regno, _Unwind_VRS_DataRepresentation representation,
 757                 void *valuep) {
 758   _LIBUNWIND_TRACE_API("_Unwind_VRS_Set(context=%p, regclass=%d, reg=%d, "
 759                        "rep=%d, value=0x%llX)",
 760                        static_cast<void *>(context), regclass, regno,
 761                        representation,
 762                        ValueAsBitPattern(representation, valuep));
 763   unw_cursor_t *cursor = (unw_cursor_t *)context;
 764   switch (regclass) {
 765     case _UVRSC_CORE:
 766       if (representation != _UVRSD_UINT32 || regno > 15)
 767         return _UVRSR_FAILED;
 768       return unw_set_reg(cursor, (unw_regnum_t)(UNW_ARM_R0 + regno),
 769                          *(unw_word_t *)valuep) == UNW_ESUCCESS
 770                  ? _UVRSR_OK
 771                  : _UVRSR_FAILED;
 772     case _UVRSC_VFP:
 773       if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
 774         return _UVRSR_FAILED;
 775       if (representation == _UVRSD_VFPX) {
 776         // Can only touch d0-15 with FSTMFDX.
 777         if (regno > 15)
 778           return _UVRSR_FAILED;
 779         unw_save_vfp_as_X(cursor);
 780       } else {
 781         if (regno > 31)
 782           return _UVRSR_FAILED;
 783       }
 784       return unw_set_fpreg(cursor, (unw_regnum_t)(UNW_ARM_D0 + regno),
 785                            *(unw_fpreg_t *)valuep) == UNW_ESUCCESS
 786                  ? _UVRSR_OK
 787                  : _UVRSR_FAILED;
 788 #if defined(__ARM_WMMX)
 789     case _UVRSC_WMMXC:
 790       if (representation != _UVRSD_UINT32 || regno > 3)
 791         return _UVRSR_FAILED;
 792       return unw_set_reg(cursor, (unw_regnum_t)(UNW_ARM_WC0 + regno),
 793                          *(unw_word_t *)valuep) == UNW_ESUCCESS
 794                  ? _UVRSR_OK
 795                  : _UVRSR_FAILED;
 796     case _UVRSC_WMMXD:
 797       if (representation != _UVRSD_DOUBLE || regno > 31)
 798         return _UVRSR_FAILED;
 799       return unw_set_fpreg(cursor, (unw_regnum_t)(UNW_ARM_WR0 + regno),
 800                            *(unw_fpreg_t *)valuep) == UNW_ESUCCESS
 801                  ? _UVRSR_OK
 802                  : _UVRSR_FAILED;
 803 #else
 804     case _UVRSC_WMMXC:
 805     case _UVRSC_WMMXD:
 806       break;
 807 #endif
 808   }
 809   _LIBUNWIND_ABORT("unsupported register class");
 810 }
 811
 812 static _Unwind_VRS_Result
 813 _Unwind_VRS_Get_Internal(_Unwind_Context *context,
 814                          _Unwind_VRS_RegClass regclass, uint32_t regno,
 815                          _Unwind_VRS_DataRepresentation representation,
 816                          void *valuep) {
 817   unw_cursor_t *cursor = (unw_cursor_t *)context;
 818   switch (regclass) {
 819     case _UVRSC_CORE:
 820       if (representation != _UVRSD_UINT32 || regno > 15)
 821         return _UVRSR_FAILED;
 822       return unw_get_reg(cursor, (unw_regnum_t)(UNW_ARM_R0 + regno),
 823                          (unw_word_t *)valuep) == UNW_ESUCCESS
 824                  ? _UVRSR_OK
 825                  : _UVRSR_FAILED;
 826     case _UVRSC_VFP:
 827       if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
 828         return _UVRSR_FAILED;
 829       if (representation == _UVRSD_VFPX) {
 830         // Can only touch d0-15 with FSTMFDX.
 831         if (regno > 15)
 832           return _UVRSR_FAILED;
 833         unw_save_vfp_as_X(cursor);
 834       } else {
 835         if (regno > 31)
 836           return _UVRSR_FAILED;
 837       }
 838       return unw_get_fpreg(cursor, (unw_regnum_t)(UNW_ARM_D0 + regno),
 839                            (unw_fpreg_t *)valuep) == UNW_ESUCCESS
 840                  ? _UVRSR_OK
 841                  : _UVRSR_FAILED;
 842 #if defined(__ARM_WMMX)
 843     case _UVRSC_WMMXC:
 844       if (representation != _UVRSD_UINT32 || regno > 3)
 845         return _UVRSR_FAILED;
 846       return unw_get_reg(cursor, (unw_regnum_t)(UNW_ARM_WC0 + regno),
 847                          (unw_word_t *)valuep) == UNW_ESUCCESS
 848                  ? _UVRSR_OK
 849                  : _UVRSR_FAILED;
 850     case _UVRSC_WMMXD:
 851       if (representation != _UVRSD_DOUBLE || regno > 31)
 852         return _UVRSR_FAILED;
 853       return unw_get_fpreg(cursor, (unw_regnum_t)(UNW_ARM_WR0 + regno),
 854                            (unw_fpreg_t *)valuep) == UNW_ESUCCESS
 855                  ? _UVRSR_OK
 856                  : _UVRSR_FAILED;
 857 #else
 858     case _UVRSC_WMMXC:
 859     case _UVRSC_WMMXD:
 860       break;
 861 #endif
 862   }
 863   _LIBUNWIND_ABORT("unsupported register class");
 864 }
 865
 866 _LIBUNWIND_EXPORT _Unwind_VRS_Result
 867 _Unwind_VRS_Get(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
 868                 uint32_t regno, _Unwind_VRS_DataRepresentation representation,
 869                 void *valuep) {
 870   _Unwind_VRS_Result result =
 871       _Unwind_VRS_Get_Internal(context, regclass, regno, representation,
 872                                valuep);
 873   _LIBUNWIND_TRACE_API("_Unwind_VRS_Get(context=%p, regclass=%d, reg=%d, "
 874                        "rep=%d, value=0x%llX, result = %d)",
 875                        static_cast<void *>(context), regclass, regno,
 876                        representation,
 877                        ValueAsBitPattern(representation, valuep), result);
 878   return result;
 879 }
 880
 881 _Unwind_VRS_Result
 882 _Unwind_VRS_Pop(_Unwind_Context *context, _Unwind_VRS_RegClass regclass,
 883                 uint32_t discriminator,
 884                 _Unwind_VRS_DataRepresentation representation) {
 885   _LIBUNWIND_TRACE_API("_Unwind_VRS_Pop(context=%p, regclass=%d, "
 886                        "discriminator=%d, representation=%d)",
 887                        static_cast<void *>(context), regclass, discriminator,
 888                        representation);
 889   switch (regclass) {
 890     case _UVRSC_WMMXC:
 891 #if !defined(__ARM_WMMX)
 892       break;
 893 #endif
 894     case _UVRSC_CORE: {
 895       if (representation != _UVRSD_UINT32)
 896         return _UVRSR_FAILED;
 897       // When popping SP from the stack, we don't want to override it from the
 898       // computed new stack location. See EHABI #7.5.4 table 3.
 899       bool poppedSP = false;
 900       uint32_t* sp;
 901       if (_Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP,
 902                           _UVRSD_UINT32, &sp) != _UVRSR_OK) {
 903         return _UVRSR_FAILED;
 904       }
 905       for (uint32_t i = 0; i < 16; ++i) {
 906         if (!(discriminator & static_cast<uint32_t>(1 << i)))
 907           continue;
 908         uint32_t value = *sp++;
 909         if (regclass == _UVRSC_CORE && i == 13)
 910           poppedSP = true;
 911         if (_Unwind_VRS_Set(context, regclass, i,
 912                             _UVRSD_UINT32, &value) != _UVRSR_OK) {
 913           return _UVRSR_FAILED;
 914         }
 915       }
 916       if (!poppedSP) {
 917         return _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP,
 918                                _UVRSD_UINT32, &sp);
 919       }
 920       return _UVRSR_OK;
 921     }
 922     case _UVRSC_WMMXD:
 923 #if !defined(__ARM_WMMX)
 924       break;
 925 #endif
 926     case _UVRSC_VFP: {
 927       if (representation != _UVRSD_VFPX && representation != _UVRSD_DOUBLE)
 928         return _UVRSR_FAILED;
 929       uint32_t first = discriminator >> 16;
 930       uint32_t count = discriminator & 0xffff;
 931       uint32_t end = first+count;
 932       uint32_t* sp;
 933       if (_Unwind_VRS_Get(context, _UVRSC_CORE, UNW_ARM_SP,
 934                           _UVRSD_UINT32, &sp) != _UVRSR_OK) {
 935         return _UVRSR_FAILED;
 936       }
 937       // For _UVRSD_VFPX, we're assuming the data is stored in FSTMX "standard
 938       // format 1", which is equivalent to FSTMD + a padding word.
 939       for (uint32_t i = first; i < end; ++i) {
 940         // SP is only 32-bit aligned so don't copy 64-bit at a time.
 941         uint64_t value = *sp++;
 942         value |= ((uint64_t)(*sp++)) << 32;
 943         if (_Unwind_VRS_Set(context, regclass, i, representation, &value) !=
 944             _UVRSR_OK)
 945           return _UVRSR_FAILED;
 946       }
 947       if (representation == _UVRSD_VFPX)
 948         ++sp;
 949       return _Unwind_VRS_Set(context, _UVRSC_CORE, UNW_ARM_SP, _UVRSD_UINT32,
 950                              &sp);
 951     }
 952   }
 953   _LIBUNWIND_ABORT("unsupported register class");
 954 }
 955
 956 /// Called by personality handler during phase 2 to find the start of the
 957 /// function.
 958 _LIBUNWIND_EXPORT uintptr_t
 959 _Unwind_GetRegionStart(struct _Unwind_Context *context) {
 960   unw_cursor_t *cursor = (unw_cursor_t *)context;
 961   unw_proc_info_t frameInfo;
 962   uintptr_t result = 0;
 963   if (unw_get_proc_info(cursor, &frameInfo) == UNW_ESUCCESS)
 964     result = (uintptr_t)frameInfo.start_ip;
 965   _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p) => 0x%llX",
 966                        static_cast<void *>(context), (long long)result);
 967   return result;
 968 }
 969
 970
 971 /// Called by personality handler during phase 2 if a foreign exception
 972 // is caught.
 973 _LIBUNWIND_EXPORT void
 974 _Unwind_DeleteException(_Unwind_Exception *exception_object) {
 975   _LIBUNWIND_TRACE_API("_Unwind_DeleteException(ex_obj=%p)",
 976                        static_cast<void *>(exception_object));
 977   if (exception_object->exception_cleanup != NULL)
 978     (*exception_object->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT,
 979                                            exception_object);
 980 }
 981
 982 extern "C" _LIBUNWIND_EXPORT _Unwind_Reason_Code
 983 __gnu_unwind_frame(_Unwind_Exception *exception_object,
 984                    struct _Unwind_Context *context) {
 985   unw_cursor_t *cursor = (unw_cursor_t *)context;
 986   if (unw_step(cursor) != UNW_STEP_SUCCESS)
 987     return _URC_FAILURE;
 988   return _URC_OK;
 989 }
 990
 991 #endif  // defined(_LIBUNWIND_ARM_EHABI)