| //===-------------------------- DwarfInstructions.hpp ---------------------===// | |
| // | |
| // The LLVM Compiler Infrastructure | |
| // | |
| // This file is dual licensed under the MIT and the University of Illinois Open | |
| // Source Licenses. See LICENSE.TXT for details. | |
| // | |
| // | |
| // Processor specific interpretation of DWARF unwind info. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #ifndef __DWARF_INSTRUCTIONS_HPP__ | |
| #define __DWARF_INSTRUCTIONS_HPP__ | |
| #include <stdint.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include "dwarf2.h" | |
| #include "Registers.hpp" | |
| #include "DwarfParser.hpp" | |
| #include "config.h" | |
| namespace libunwind { | |
| /// DwarfInstructions maps abtract DWARF unwind instructions to a particular | |
| /// architecture | |
| template <typename A, typename R> | |
| class DwarfInstructions { | |
| public: | |
| typedef typename A::pint_t pint_t; | |
| typedef typename A::sint_t sint_t; | |
| static int stepWithDwarf(A &addressSpace, pint_t pc, pint_t fdeStart, | |
| R ®isters); | |
| private: | |
| enum { | |
| DW_X86_64_RET_ADDR = 16 | |
| }; | |
| enum { | |
| DW_X86_RET_ADDR = 8 | |
| }; | |
| typedef typename CFI_Parser<A>::RegisterLocation RegisterLocation; | |
| typedef typename CFI_Parser<A>::PrologInfo PrologInfo; | |
| typedef typename CFI_Parser<A>::FDE_Info FDE_Info; | |
| typedef typename CFI_Parser<A>::CIE_Info CIE_Info; | |
| static pint_t evaluateExpression(pint_t expression, A &addressSpace, | |
| const R ®isters, | |
| pint_t initialStackValue); | |
| static pint_t getSavedRegister(A &addressSpace, const R ®isters, | |
| pint_t cfa, const RegisterLocation &savedReg); | |
| static double getSavedFloatRegister(A &addressSpace, const R ®isters, | |
| pint_t cfa, const RegisterLocation &savedReg); | |
| static v128 getSavedVectorRegister(A &addressSpace, const R ®isters, | |
| pint_t cfa, const RegisterLocation &savedReg); | |
| static pint_t getCFA(A &addressSpace, const PrologInfo &prolog, | |
| const R ®isters) { | |
| if (prolog.cfaRegister != 0) | |
| return (pint_t)((sint_t)registers.getRegister((int)prolog.cfaRegister) + | |
| prolog.cfaRegisterOffset); | |
| if (prolog.cfaExpression != 0) | |
| return evaluateExpression((pint_t)prolog.cfaExpression, addressSpace, | |
| registers, 0); | |
| assert(0 && "getCFA(): unknown location"); | |
| __builtin_unreachable(); | |
| } | |
| }; | |
| template <typename A, typename R> | |
| typename A::pint_t DwarfInstructions<A, R>::getSavedRegister( | |
| A &addressSpace, const R ®isters, pint_t cfa, | |
| const RegisterLocation &savedReg) { | |
| switch (savedReg.location) { | |
| case CFI_Parser<A>::kRegisterInCFA: | |
| return addressSpace.getRegister(cfa + (pint_t)savedReg.value); | |
| case CFI_Parser<A>::kRegisterAtExpression: | |
| return addressSpace.getRegister( | |
| evaluateExpression((pint_t)savedReg.value, addressSpace, | |
| registers, cfa)); | |
| case CFI_Parser<A>::kRegisterIsExpression: | |
| return evaluateExpression((pint_t)savedReg.value, addressSpace, | |
| registers, cfa); | |
| case CFI_Parser<A>::kRegisterInRegister: | |
| return registers.getRegister((int)savedReg.value); | |
| case CFI_Parser<A>::kRegisterUnused: | |
| case CFI_Parser<A>::kRegisterOffsetFromCFA: | |
| // FIX ME | |
| break; | |
| } | |
| _LIBUNWIND_ABORT("unsupported restore location for register"); | |
| } | |
| template <typename A, typename R> | |
| double DwarfInstructions<A, R>::getSavedFloatRegister( | |
| A &addressSpace, const R ®isters, pint_t cfa, | |
| const RegisterLocation &savedReg) { | |
| switch (savedReg.location) { | |
| case CFI_Parser<A>::kRegisterInCFA: | |
| return addressSpace.getDouble(cfa + (pint_t)savedReg.value); | |
| case CFI_Parser<A>::kRegisterAtExpression: | |
| return addressSpace.getDouble( | |
| evaluateExpression((pint_t)savedReg.value, addressSpace, | |
| registers, cfa)); | |
| case CFI_Parser<A>::kRegisterIsExpression: | |
| case CFI_Parser<A>::kRegisterUnused: | |
| case CFI_Parser<A>::kRegisterOffsetFromCFA: | |
| case CFI_Parser<A>::kRegisterInRegister: | |
| // FIX ME | |
| break; | |
| } | |
| _LIBUNWIND_ABORT("unsupported restore location for float register"); | |
| } | |
| template <typename A, typename R> | |
| v128 DwarfInstructions<A, R>::getSavedVectorRegister( | |
| A &addressSpace, const R ®isters, pint_t cfa, | |
| const RegisterLocation &savedReg) { | |
| switch (savedReg.location) { | |
| case CFI_Parser<A>::kRegisterInCFA: | |
| return addressSpace.getVector(cfa + (pint_t)savedReg.value); | |
| case CFI_Parser<A>::kRegisterAtExpression: | |
| return addressSpace.getVector( | |
| evaluateExpression((pint_t)savedReg.value, addressSpace, | |
| registers, cfa)); | |
| case CFI_Parser<A>::kRegisterIsExpression: | |
| case CFI_Parser<A>::kRegisterUnused: | |
| case CFI_Parser<A>::kRegisterOffsetFromCFA: | |
| case CFI_Parser<A>::kRegisterInRegister: | |
| // FIX ME | |
| break; | |
| } | |
| _LIBUNWIND_ABORT("unsupported restore location for vector register"); | |
| } | |
| template <typename A, typename R> | |
| int DwarfInstructions<A, R>::stepWithDwarf(A &addressSpace, pint_t pc, | |
| pint_t fdeStart, R ®isters) { | |
| FDE_Info fdeInfo; | |
| CIE_Info cieInfo; | |
| if (CFI_Parser<A>::decodeFDE(addressSpace, fdeStart, &fdeInfo, | |
| &cieInfo) == NULL) { | |
| PrologInfo prolog; | |
| if (CFI_Parser<A>::parseFDEInstructions(addressSpace, fdeInfo, cieInfo, pc, | |
| &prolog)) { | |
| // get pointer to cfa (architecture specific) | |
| pint_t cfa = getCFA(addressSpace, prolog, registers); | |
| // restore registers that DWARF says were saved | |
| R newRegisters = registers; | |
| pint_t returnAddress = 0; | |
| const int lastReg = R::lastDwarfRegNum(); | |
| assert(static_cast<int>(CFI_Parser<A>::kMaxRegisterNumber) >= lastReg && | |
| "register range too large"); | |
| assert(lastReg >= (int)cieInfo.returnAddressRegister && | |
| "register range does not contain return address register"); | |
| for (int i = 0; i <= lastReg; ++i) { | |
| if (prolog.savedRegisters[i].location != | |
| CFI_Parser<A>::kRegisterUnused) { | |
| if (registers.validFloatRegister(i)) | |
| newRegisters.setFloatRegister( | |
| i, getSavedFloatRegister(addressSpace, registers, cfa, | |
| prolog.savedRegisters[i])); | |
| else if (registers.validVectorRegister(i)) | |
| newRegisters.setVectorRegister( | |
| i, getSavedVectorRegister(addressSpace, registers, cfa, | |
| prolog.savedRegisters[i])); | |
| else if (i == (int)cieInfo.returnAddressRegister) | |
| returnAddress = getSavedRegister(addressSpace, registers, cfa, | |
| prolog.savedRegisters[i]); | |
| else if (registers.validRegister(i)) | |
| newRegisters.setRegister( | |
| i, getSavedRegister(addressSpace, registers, cfa, | |
| prolog.savedRegisters[i])); | |
| else | |
| return UNW_EBADREG; | |
| } | |
| } | |
| // By definition, the CFA is the stack pointer at the call site, so | |
| // restoring SP means setting it to CFA. | |
| newRegisters.setSP(cfa); | |
| // Return address is address after call site instruction, so setting IP to | |
| // that does simualates a return. | |
| newRegisters.setIP(returnAddress); | |
| // Simulate the step by replacing the register set with the new ones. | |
| registers = newRegisters; | |
| return UNW_STEP_SUCCESS; | |
| } | |
| } | |
| return UNW_EBADFRAME; | |
| } | |
| template <typename A, typename R> | |
| typename A::pint_t | |
| DwarfInstructions<A, R>::evaluateExpression(pint_t expression, A &addressSpace, | |
| const R ®isters, | |
| pint_t initialStackValue) { | |
| const bool log = false; | |
| pint_t p = expression; | |
| pint_t expressionEnd = expression + 20; // temp, until len read | |
| pint_t length = (pint_t)addressSpace.getULEB128(p, expressionEnd); | |
| expressionEnd = p + length; | |
| if (log) | |
| fprintf(stderr, "evaluateExpression(): length=%" PRIu64 "\n", | |
| (uint64_t)length); | |
| pint_t stack[100]; | |
| pint_t *sp = stack; | |
| *(++sp) = initialStackValue; | |
| while (p < expressionEnd) { | |
| if (log) { | |
| for (pint_t *t = sp; t > stack; --t) { | |
| fprintf(stderr, "sp[] = 0x%" PRIx64 "\n", (uint64_t)(*t)); | |
| } | |
| } | |
| uint8_t opcode = addressSpace.get8(p++); | |
| sint_t svalue, svalue2; | |
| pint_t value; | |
| uint32_t reg; | |
| switch (opcode) { | |
| case DW_OP_addr: | |
| // push immediate address sized value | |
| value = addressSpace.getP(p); | |
| p += sizeof(pint_t); | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_deref: | |
| // pop stack, dereference, push result | |
| value = *sp--; | |
| *(++sp) = addressSpace.getP(value); | |
| if (log) | |
| fprintf(stderr, "dereference 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_const1u: | |
| // push immediate 1 byte value | |
| value = addressSpace.get8(p); | |
| p += 1; | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_const1s: | |
| // push immediate 1 byte signed value | |
| svalue = (int8_t) addressSpace.get8(p); | |
| p += 1; | |
| *(++sp) = (pint_t)svalue; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue); | |
| break; | |
| case DW_OP_const2u: | |
| // push immediate 2 byte value | |
| value = addressSpace.get16(p); | |
| p += 2; | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_const2s: | |
| // push immediate 2 byte signed value | |
| svalue = (int16_t) addressSpace.get16(p); | |
| p += 2; | |
| *(++sp) = (pint_t)svalue; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue); | |
| break; | |
| case DW_OP_const4u: | |
| // push immediate 4 byte value | |
| value = addressSpace.get32(p); | |
| p += 4; | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_const4s: | |
| // push immediate 4 byte signed value | |
| svalue = (int32_t)addressSpace.get32(p); | |
| p += 4; | |
| *(++sp) = (pint_t)svalue; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue); | |
| break; | |
| case DW_OP_const8u: | |
| // push immediate 8 byte value | |
| value = (pint_t)addressSpace.get64(p); | |
| p += 8; | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_const8s: | |
| // push immediate 8 byte signed value | |
| value = (pint_t)addressSpace.get64(p); | |
| p += 8; | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_constu: | |
| // push immediate ULEB128 value | |
| value = (pint_t)addressSpace.getULEB128(p, expressionEnd); | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_consts: | |
| // push immediate SLEB128 value | |
| svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd); | |
| *(++sp) = (pint_t)svalue; | |
| if (log) | |
| fprintf(stderr, "push 0x%" PRIx64 "\n", (uint64_t)svalue); | |
| break; | |
| case DW_OP_dup: | |
| // push top of stack | |
| value = *sp; | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "duplicate top of stack\n"); | |
| break; | |
| case DW_OP_drop: | |
| // pop | |
| --sp; | |
| if (log) | |
| fprintf(stderr, "pop top of stack\n"); | |
| break; | |
| case DW_OP_over: | |
| // dup second | |
| value = sp[-1]; | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "duplicate second in stack\n"); | |
| break; | |
| case DW_OP_pick: | |
| // pick from | |
| reg = addressSpace.get8(p); | |
| p += 1; | |
| value = sp[-reg]; | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "duplicate %d in stack\n", reg); | |
| break; | |
| case DW_OP_swap: | |
| // swap top two | |
| value = sp[0]; | |
| sp[0] = sp[-1]; | |
| sp[-1] = value; | |
| if (log) | |
| fprintf(stderr, "swap top of stack\n"); | |
| break; | |
| case DW_OP_rot: | |
| // rotate top three | |
| value = sp[0]; | |
| sp[0] = sp[-1]; | |
| sp[-1] = sp[-2]; | |
| sp[-2] = value; | |
| if (log) | |
| fprintf(stderr, "rotate top three of stack\n"); | |
| break; | |
| case DW_OP_xderef: | |
| // pop stack, dereference, push result | |
| value = *sp--; | |
| *sp = *((pint_t*)value); | |
| if (log) | |
| fprintf(stderr, "x-dereference 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_abs: | |
| svalue = (sint_t)*sp; | |
| if (svalue < 0) | |
| *sp = (pint_t)(-svalue); | |
| if (log) | |
| fprintf(stderr, "abs\n"); | |
| break; | |
| case DW_OP_and: | |
| value = *sp--; | |
| *sp &= value; | |
| if (log) | |
| fprintf(stderr, "and\n"); | |
| break; | |
| case DW_OP_div: | |
| svalue = (sint_t)(*sp--); | |
| svalue2 = (sint_t)*sp; | |
| *sp = (pint_t)(svalue2 / svalue); | |
| if (log) | |
| fprintf(stderr, "div\n"); | |
| break; | |
| case DW_OP_minus: | |
| value = *sp--; | |
| *sp = *sp - value; | |
| if (log) | |
| fprintf(stderr, "minus\n"); | |
| break; | |
| case DW_OP_mod: | |
| svalue = (sint_t)(*sp--); | |
| svalue2 = (sint_t)*sp; | |
| *sp = (pint_t)(svalue2 % svalue); | |
| if (log) | |
| fprintf(stderr, "module\n"); | |
| break; | |
| case DW_OP_mul: | |
| svalue = (sint_t)(*sp--); | |
| svalue2 = (sint_t)*sp; | |
| *sp = (pint_t)(svalue2 * svalue); | |
| if (log) | |
| fprintf(stderr, "mul\n"); | |
| break; | |
| case DW_OP_neg: | |
| *sp = 0 - *sp; | |
| if (log) | |
| fprintf(stderr, "neg\n"); | |
| break; | |
| case DW_OP_not: | |
| svalue = (sint_t)(*sp); | |
| *sp = (pint_t)(~svalue); | |
| if (log) | |
| fprintf(stderr, "not\n"); | |
| break; | |
| case DW_OP_or: | |
| value = *sp--; | |
| *sp |= value; | |
| if (log) | |
| fprintf(stderr, "or\n"); | |
| break; | |
| case DW_OP_plus: | |
| value = *sp--; | |
| *sp += value; | |
| if (log) | |
| fprintf(stderr, "plus\n"); | |
| break; | |
| case DW_OP_plus_uconst: | |
| // pop stack, add uelb128 constant, push result | |
| *sp += static_cast<pint_t>(addressSpace.getULEB128(p, expressionEnd)); | |
| if (log) | |
| fprintf(stderr, "add constant\n"); | |
| break; | |
| case DW_OP_shl: | |
| value = *sp--; | |
| *sp = *sp << value; | |
| if (log) | |
| fprintf(stderr, "shift left\n"); | |
| break; | |
| case DW_OP_shr: | |
| value = *sp--; | |
| *sp = *sp >> value; | |
| if (log) | |
| fprintf(stderr, "shift left\n"); | |
| break; | |
| case DW_OP_shra: | |
| value = *sp--; | |
| svalue = (sint_t)*sp; | |
| *sp = (pint_t)(svalue >> value); | |
| if (log) | |
| fprintf(stderr, "shift left arithmetric\n"); | |
| break; | |
| case DW_OP_xor: | |
| value = *sp--; | |
| *sp ^= value; | |
| if (log) | |
| fprintf(stderr, "xor\n"); | |
| break; | |
| case DW_OP_skip: | |
| svalue = (int16_t) addressSpace.get16(p); | |
| p += 2; | |
| p = (pint_t)((sint_t)p + svalue); | |
| if (log) | |
| fprintf(stderr, "skip %" PRIu64 "\n", (uint64_t)svalue); | |
| break; | |
| case DW_OP_bra: | |
| svalue = (int16_t) addressSpace.get16(p); | |
| p += 2; | |
| if (*sp--) | |
| p = (pint_t)((sint_t)p + svalue); | |
| if (log) | |
| fprintf(stderr, "bra %" PRIu64 "\n", (uint64_t)svalue); | |
| break; | |
| case DW_OP_eq: | |
| value = *sp--; | |
| *sp = (*sp == value); | |
| if (log) | |
| fprintf(stderr, "eq\n"); | |
| break; | |
| case DW_OP_ge: | |
| value = *sp--; | |
| *sp = (*sp >= value); | |
| if (log) | |
| fprintf(stderr, "ge\n"); | |
| break; | |
| case DW_OP_gt: | |
| value = *sp--; | |
| *sp = (*sp > value); | |
| if (log) | |
| fprintf(stderr, "gt\n"); | |
| break; | |
| case DW_OP_le: | |
| value = *sp--; | |
| *sp = (*sp <= value); | |
| if (log) | |
| fprintf(stderr, "le\n"); | |
| break; | |
| case DW_OP_lt: | |
| value = *sp--; | |
| *sp = (*sp < value); | |
| if (log) | |
| fprintf(stderr, "lt\n"); | |
| break; | |
| case DW_OP_ne: | |
| value = *sp--; | |
| *sp = (*sp != value); | |
| if (log) | |
| fprintf(stderr, "ne\n"); | |
| break; | |
| case DW_OP_lit0: | |
| case DW_OP_lit1: | |
| case DW_OP_lit2: | |
| case DW_OP_lit3: | |
| case DW_OP_lit4: | |
| case DW_OP_lit5: | |
| case DW_OP_lit6: | |
| case DW_OP_lit7: | |
| case DW_OP_lit8: | |
| case DW_OP_lit9: | |
| case DW_OP_lit10: | |
| case DW_OP_lit11: | |
| case DW_OP_lit12: | |
| case DW_OP_lit13: | |
| case DW_OP_lit14: | |
| case DW_OP_lit15: | |
| case DW_OP_lit16: | |
| case DW_OP_lit17: | |
| case DW_OP_lit18: | |
| case DW_OP_lit19: | |
| case DW_OP_lit20: | |
| case DW_OP_lit21: | |
| case DW_OP_lit22: | |
| case DW_OP_lit23: | |
| case DW_OP_lit24: | |
| case DW_OP_lit25: | |
| case DW_OP_lit26: | |
| case DW_OP_lit27: | |
| case DW_OP_lit28: | |
| case DW_OP_lit29: | |
| case DW_OP_lit30: | |
| case DW_OP_lit31: | |
| value = static_cast<pint_t>(opcode - DW_OP_lit0); | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "push literal 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_reg0: | |
| case DW_OP_reg1: | |
| case DW_OP_reg2: | |
| case DW_OP_reg3: | |
| case DW_OP_reg4: | |
| case DW_OP_reg5: | |
| case DW_OP_reg6: | |
| case DW_OP_reg7: | |
| case DW_OP_reg8: | |
| case DW_OP_reg9: | |
| case DW_OP_reg10: | |
| case DW_OP_reg11: | |
| case DW_OP_reg12: | |
| case DW_OP_reg13: | |
| case DW_OP_reg14: | |
| case DW_OP_reg15: | |
| case DW_OP_reg16: | |
| case DW_OP_reg17: | |
| case DW_OP_reg18: | |
| case DW_OP_reg19: | |
| case DW_OP_reg20: | |
| case DW_OP_reg21: | |
| case DW_OP_reg22: | |
| case DW_OP_reg23: | |
| case DW_OP_reg24: | |
| case DW_OP_reg25: | |
| case DW_OP_reg26: | |
| case DW_OP_reg27: | |
| case DW_OP_reg28: | |
| case DW_OP_reg29: | |
| case DW_OP_reg30: | |
| case DW_OP_reg31: | |
| reg = static_cast<uint32_t>(opcode - DW_OP_reg0); | |
| *(++sp) = registers.getRegister((int)reg); | |
| if (log) | |
| fprintf(stderr, "push reg %d\n", reg); | |
| break; | |
| case DW_OP_regx: | |
| reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd)); | |
| *(++sp) = registers.getRegister((int)reg); | |
| if (log) | |
| fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue); | |
| break; | |
| case DW_OP_breg0: | |
| case DW_OP_breg1: | |
| case DW_OP_breg2: | |
| case DW_OP_breg3: | |
| case DW_OP_breg4: | |
| case DW_OP_breg5: | |
| case DW_OP_breg6: | |
| case DW_OP_breg7: | |
| case DW_OP_breg8: | |
| case DW_OP_breg9: | |
| case DW_OP_breg10: | |
| case DW_OP_breg11: | |
| case DW_OP_breg12: | |
| case DW_OP_breg13: | |
| case DW_OP_breg14: | |
| case DW_OP_breg15: | |
| case DW_OP_breg16: | |
| case DW_OP_breg17: | |
| case DW_OP_breg18: | |
| case DW_OP_breg19: | |
| case DW_OP_breg20: | |
| case DW_OP_breg21: | |
| case DW_OP_breg22: | |
| case DW_OP_breg23: | |
| case DW_OP_breg24: | |
| case DW_OP_breg25: | |
| case DW_OP_breg26: | |
| case DW_OP_breg27: | |
| case DW_OP_breg28: | |
| case DW_OP_breg29: | |
| case DW_OP_breg30: | |
| case DW_OP_breg31: | |
| reg = static_cast<uint32_t>(opcode - DW_OP_breg0); | |
| svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd); | |
| svalue += static_cast<sint_t>(registers.getRegister((int)reg)); | |
| *(++sp) = (pint_t)(svalue); | |
| if (log) | |
| fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue); | |
| break; | |
| case DW_OP_bregx: | |
| reg = static_cast<uint32_t>(addressSpace.getULEB128(p, expressionEnd)); | |
| svalue = (sint_t)addressSpace.getSLEB128(p, expressionEnd); | |
| svalue += static_cast<sint_t>(registers.getRegister((int)reg)); | |
| *(++sp) = (pint_t)(svalue); | |
| if (log) | |
| fprintf(stderr, "push reg %d + 0x%" PRIx64 "\n", reg, (uint64_t)svalue); | |
| break; | |
| case DW_OP_fbreg: | |
| _LIBUNWIND_ABORT("DW_OP_fbreg not implemented"); | |
| break; | |
| case DW_OP_piece: | |
| _LIBUNWIND_ABORT("DW_OP_piece not implemented"); | |
| break; | |
| case DW_OP_deref_size: | |
| // pop stack, dereference, push result | |
| value = *sp--; | |
| switch (addressSpace.get8(p++)) { | |
| case 1: | |
| value = addressSpace.get8(value); | |
| break; | |
| case 2: | |
| value = addressSpace.get16(value); | |
| break; | |
| case 4: | |
| value = addressSpace.get32(value); | |
| break; | |
| case 8: | |
| value = (pint_t)addressSpace.get64(value); | |
| break; | |
| default: | |
| _LIBUNWIND_ABORT("DW_OP_deref_size with bad size"); | |
| } | |
| *(++sp) = value; | |
| if (log) | |
| fprintf(stderr, "sized dereference 0x%" PRIx64 "\n", (uint64_t)value); | |
| break; | |
| case DW_OP_xderef_size: | |
| case DW_OP_nop: | |
| case DW_OP_push_object_addres: | |
| case DW_OP_call2: | |
| case DW_OP_call4: | |
| case DW_OP_call_ref: | |
| default: | |
| _LIBUNWIND_ABORT("DWARF opcode not implemented"); | |
| } | |
| } | |
| if (log) | |
| fprintf(stderr, "expression evaluates to 0x%" PRIx64 "\n", (uint64_t)*sp); | |
| return *sp; | |
| } | |
| } // namespace libunwind | |
| #endif // __DWARF_INSTRUCTIONS_HPP__ |