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