| //===-- DWARFExpression.cpp -------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/Expression/DWARFExpression.h" |
| |
| #include <vector> |
| |
| #include "lldb/Core/dwarf.h" |
| #include "lldb/Core/Log.h" |
| #include "lldb/Core/StreamString.h" |
| #include "lldb/Core/Scalar.h" |
| #include "lldb/Core/Value.h" |
| #include "lldb/Core/VMRange.h" |
| |
| #include "lldb/Expression/ClangExpressionDeclMap.h" |
| #include "lldb/Expression/ClangExpressionVariable.h" |
| |
| #include "lldb/Host/Host.h" |
| |
| #include "lldb/lldb-private-log.h" |
| |
| #include "lldb/Symbol/ClangASTType.h" |
| #include "lldb/Symbol/ClangASTContext.h" |
| #include "lldb/Symbol/Type.h" |
| |
| #include "lldb/Target/ExecutionContext.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Target/RegisterContext.h" |
| #include "lldb/Target/StackFrame.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| const char * |
| DW_OP_value_to_name (uint32_t val) |
| { |
| static char invalid[100]; |
| switch (val) { |
| case 0x03: return "DW_OP_addr"; |
| case 0x06: return "DW_OP_deref"; |
| case 0x08: return "DW_OP_const1u"; |
| case 0x09: return "DW_OP_const1s"; |
| case 0x0a: return "DW_OP_const2u"; |
| case 0x0b: return "DW_OP_const2s"; |
| case 0x0c: return "DW_OP_const4u"; |
| case 0x0d: return "DW_OP_const4s"; |
| case 0x0e: return "DW_OP_const8u"; |
| case 0x0f: return "DW_OP_const8s"; |
| case 0x10: return "DW_OP_constu"; |
| case 0x11: return "DW_OP_consts"; |
| case 0x12: return "DW_OP_dup"; |
| case 0x13: return "DW_OP_drop"; |
| case 0x14: return "DW_OP_over"; |
| case 0x15: return "DW_OP_pick"; |
| case 0x16: return "DW_OP_swap"; |
| case 0x17: return "DW_OP_rot"; |
| case 0x18: return "DW_OP_xderef"; |
| case 0x19: return "DW_OP_abs"; |
| case 0x1a: return "DW_OP_and"; |
| case 0x1b: return "DW_OP_div"; |
| case 0x1c: return "DW_OP_minus"; |
| case 0x1d: return "DW_OP_mod"; |
| case 0x1e: return "DW_OP_mul"; |
| case 0x1f: return "DW_OP_neg"; |
| case 0x20: return "DW_OP_not"; |
| case 0x21: return "DW_OP_or"; |
| case 0x22: return "DW_OP_plus"; |
| case 0x23: return "DW_OP_plus_uconst"; |
| case 0x24: return "DW_OP_shl"; |
| case 0x25: return "DW_OP_shr"; |
| case 0x26: return "DW_OP_shra"; |
| case 0x27: return "DW_OP_xor"; |
| case 0x2f: return "DW_OP_skip"; |
| case 0x28: return "DW_OP_bra"; |
| case 0x29: return "DW_OP_eq"; |
| case 0x2a: return "DW_OP_ge"; |
| case 0x2b: return "DW_OP_gt"; |
| case 0x2c: return "DW_OP_le"; |
| case 0x2d: return "DW_OP_lt"; |
| case 0x2e: return "DW_OP_ne"; |
| case 0x30: return "DW_OP_lit0"; |
| case 0x31: return "DW_OP_lit1"; |
| case 0x32: return "DW_OP_lit2"; |
| case 0x33: return "DW_OP_lit3"; |
| case 0x34: return "DW_OP_lit4"; |
| case 0x35: return "DW_OP_lit5"; |
| case 0x36: return "DW_OP_lit6"; |
| case 0x37: return "DW_OP_lit7"; |
| case 0x38: return "DW_OP_lit8"; |
| case 0x39: return "DW_OP_lit9"; |
| case 0x3a: return "DW_OP_lit10"; |
| case 0x3b: return "DW_OP_lit11"; |
| case 0x3c: return "DW_OP_lit12"; |
| case 0x3d: return "DW_OP_lit13"; |
| case 0x3e: return "DW_OP_lit14"; |
| case 0x3f: return "DW_OP_lit15"; |
| case 0x40: return "DW_OP_lit16"; |
| case 0x41: return "DW_OP_lit17"; |
| case 0x42: return "DW_OP_lit18"; |
| case 0x43: return "DW_OP_lit19"; |
| case 0x44: return "DW_OP_lit20"; |
| case 0x45: return "DW_OP_lit21"; |
| case 0x46: return "DW_OP_lit22"; |
| case 0x47: return "DW_OP_lit23"; |
| case 0x48: return "DW_OP_lit24"; |
| case 0x49: return "DW_OP_lit25"; |
| case 0x4a: return "DW_OP_lit26"; |
| case 0x4b: return "DW_OP_lit27"; |
| case 0x4c: return "DW_OP_lit28"; |
| case 0x4d: return "DW_OP_lit29"; |
| case 0x4e: return "DW_OP_lit30"; |
| case 0x4f: return "DW_OP_lit31"; |
| case 0x50: return "DW_OP_reg0"; |
| case 0x51: return "DW_OP_reg1"; |
| case 0x52: return "DW_OP_reg2"; |
| case 0x53: return "DW_OP_reg3"; |
| case 0x54: return "DW_OP_reg4"; |
| case 0x55: return "DW_OP_reg5"; |
| case 0x56: return "DW_OP_reg6"; |
| case 0x57: return "DW_OP_reg7"; |
| case 0x58: return "DW_OP_reg8"; |
| case 0x59: return "DW_OP_reg9"; |
| case 0x5a: return "DW_OP_reg10"; |
| case 0x5b: return "DW_OP_reg11"; |
| case 0x5c: return "DW_OP_reg12"; |
| case 0x5d: return "DW_OP_reg13"; |
| case 0x5e: return "DW_OP_reg14"; |
| case 0x5f: return "DW_OP_reg15"; |
| case 0x60: return "DW_OP_reg16"; |
| case 0x61: return "DW_OP_reg17"; |
| case 0x62: return "DW_OP_reg18"; |
| case 0x63: return "DW_OP_reg19"; |
| case 0x64: return "DW_OP_reg20"; |
| case 0x65: return "DW_OP_reg21"; |
| case 0x66: return "DW_OP_reg22"; |
| case 0x67: return "DW_OP_reg23"; |
| case 0x68: return "DW_OP_reg24"; |
| case 0x69: return "DW_OP_reg25"; |
| case 0x6a: return "DW_OP_reg26"; |
| case 0x6b: return "DW_OP_reg27"; |
| case 0x6c: return "DW_OP_reg28"; |
| case 0x6d: return "DW_OP_reg29"; |
| case 0x6e: return "DW_OP_reg30"; |
| case 0x6f: return "DW_OP_reg31"; |
| case 0x70: return "DW_OP_breg0"; |
| case 0x71: return "DW_OP_breg1"; |
| case 0x72: return "DW_OP_breg2"; |
| case 0x73: return "DW_OP_breg3"; |
| case 0x74: return "DW_OP_breg4"; |
| case 0x75: return "DW_OP_breg5"; |
| case 0x76: return "DW_OP_breg6"; |
| case 0x77: return "DW_OP_breg7"; |
| case 0x78: return "DW_OP_breg8"; |
| case 0x79: return "DW_OP_breg9"; |
| case 0x7a: return "DW_OP_breg10"; |
| case 0x7b: return "DW_OP_breg11"; |
| case 0x7c: return "DW_OP_breg12"; |
| case 0x7d: return "DW_OP_breg13"; |
| case 0x7e: return "DW_OP_breg14"; |
| case 0x7f: return "DW_OP_breg15"; |
| case 0x80: return "DW_OP_breg16"; |
| case 0x81: return "DW_OP_breg17"; |
| case 0x82: return "DW_OP_breg18"; |
| case 0x83: return "DW_OP_breg19"; |
| case 0x84: return "DW_OP_breg20"; |
| case 0x85: return "DW_OP_breg21"; |
| case 0x86: return "DW_OP_breg22"; |
| case 0x87: return "DW_OP_breg23"; |
| case 0x88: return "DW_OP_breg24"; |
| case 0x89: return "DW_OP_breg25"; |
| case 0x8a: return "DW_OP_breg26"; |
| case 0x8b: return "DW_OP_breg27"; |
| case 0x8c: return "DW_OP_breg28"; |
| case 0x8d: return "DW_OP_breg29"; |
| case 0x8e: return "DW_OP_breg30"; |
| case 0x8f: return "DW_OP_breg31"; |
| case 0x90: return "DW_OP_regx"; |
| case 0x91: return "DW_OP_fbreg"; |
| case 0x92: return "DW_OP_bregx"; |
| case 0x93: return "DW_OP_piece"; |
| case 0x94: return "DW_OP_deref_size"; |
| case 0x95: return "DW_OP_xderef_size"; |
| case 0x96: return "DW_OP_nop"; |
| case 0x97: return "DW_OP_push_object_address"; |
| case 0x98: return "DW_OP_call2"; |
| case 0x99: return "DW_OP_call4"; |
| case 0x9a: return "DW_OP_call_ref"; |
| case DW_OP_APPLE_array_ref: return "DW_OP_APPLE_array_ref"; |
| case DW_OP_APPLE_extern: return "DW_OP_APPLE_extern"; |
| case DW_OP_APPLE_uninit: return "DW_OP_APPLE_uninit"; |
| case DW_OP_APPLE_assign: return "DW_OP_APPLE_assign"; |
| case DW_OP_APPLE_address_of: return "DW_OP_APPLE_address_of"; |
| case DW_OP_APPLE_value_of: return "DW_OP_APPLE_value_of"; |
| case DW_OP_APPLE_deref_type: return "DW_OP_APPLE_deref_type"; |
| case DW_OP_APPLE_expr_local: return "DW_OP_APPLE_expr_local"; |
| case DW_OP_APPLE_constf: return "DW_OP_APPLE_constf"; |
| case DW_OP_APPLE_scalar_cast: return "DW_OP_APPLE_scalar_cast"; |
| case DW_OP_APPLE_clang_cast: return "DW_OP_APPLE_clang_cast"; |
| case DW_OP_APPLE_clear: return "DW_OP_APPLE_clear"; |
| case DW_OP_APPLE_error: return "DW_OP_APPLE_error"; |
| default: |
| snprintf (invalid, sizeof(invalid), "Unknown DW_OP constant: 0x%x", val); |
| return invalid; |
| } |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // DWARFExpression constructor |
| //---------------------------------------------------------------------- |
| DWARFExpression::DWARFExpression() : |
| m_data(), |
| m_reg_kind (eRegisterKindDWARF), |
| m_loclist_slide (LLDB_INVALID_ADDRESS), |
| m_expr_locals (NULL), |
| m_decl_map (NULL) |
| { |
| } |
| |
| DWARFExpression::DWARFExpression(const DWARFExpression& rhs) : |
| m_data(rhs.m_data), |
| m_reg_kind (rhs.m_reg_kind), |
| m_loclist_slide(rhs.m_loclist_slide), |
| m_expr_locals (rhs.m_expr_locals), |
| m_decl_map (rhs.m_decl_map) |
| { |
| } |
| |
| |
| DWARFExpression::DWARFExpression(const DataExtractor& data, uint32_t data_offset, uint32_t data_length) : |
| m_data(data, data_offset, data_length), |
| m_reg_kind (eRegisterKindDWARF), |
| m_loclist_slide(LLDB_INVALID_ADDRESS), |
| m_expr_locals (NULL), |
| m_decl_map (NULL) |
| { |
| } |
| |
| //---------------------------------------------------------------------- |
| // Destructor |
| //---------------------------------------------------------------------- |
| DWARFExpression::~DWARFExpression() |
| { |
| } |
| |
| |
| bool |
| DWARFExpression::IsValid() const |
| { |
| return m_data.GetByteSize() > 0; |
| } |
| |
| |
| void |
| DWARFExpression::SetExpressionLocalVariableList (ClangExpressionVariableList *locals) |
| { |
| m_expr_locals = locals; |
| } |
| |
| void |
| DWARFExpression::SetExpressionDeclMap (ClangExpressionDeclMap *decl_map) |
| { |
| m_decl_map = decl_map; |
| } |
| |
| void |
| DWARFExpression::SetOpcodeData (const DataExtractor& data) |
| { |
| m_data = data; |
| } |
| |
| void |
| DWARFExpression::SetOpcodeData (const DataExtractor& data, uint32_t data_offset, uint32_t data_length) |
| { |
| m_data.SetData(data, data_offset, data_length); |
| } |
| |
| void |
| DWARFExpression::DumpLocation (Stream *s, uint32_t offset, uint32_t length, lldb::DescriptionLevel level) const |
| { |
| if (!m_data.ValidOffsetForDataOfSize(offset, length)) |
| return; |
| const uint32_t start_offset = offset; |
| const uint32_t end_offset = offset + length; |
| while (m_data.ValidOffset(offset) && offset < end_offset) |
| { |
| const uint32_t op_offset = offset; |
| const uint8_t op = m_data.GetU8(&offset); |
| |
| switch (level) |
| { |
| default: |
| break; |
| |
| case lldb::eDescriptionLevelBrief: |
| if (offset > start_offset) |
| s->PutChar(' '); |
| break; |
| |
| case lldb::eDescriptionLevelFull: |
| case lldb::eDescriptionLevelVerbose: |
| if (offset > start_offset) |
| s->EOL(); |
| s->Indent(); |
| if (level == lldb::eDescriptionLevelFull) |
| break; |
| // Fall through for verbose and print offset and DW_OP prefix.. |
| s->Printf("0x%8.8x: %s", op_offset, op >= DW_OP_APPLE_uninit ? "DW_OP_APPLE_" : "DW_OP_"); |
| break; |
| } |
| |
| switch (op) |
| { |
| case DW_OP_addr: *s << "addr(" << m_data.GetAddress(&offset) << ") "; break; // 0x03 1 address |
| case DW_OP_deref: *s << "deref"; break; // 0x06 |
| case DW_OP_const1u: s->Printf("const1u(0x%2.2x) ", m_data.GetU8(&offset)); break; // 0x08 1 1-byte constant |
| case DW_OP_const1s: s->Printf("const1s(0x%2.2x) ", m_data.GetU8(&offset)); break; // 0x09 1 1-byte constant |
| case DW_OP_const2u: s->Printf("const2u(0x%4.4x) ", m_data.GetU16(&offset)); break; // 0x0a 1 2-byte constant |
| case DW_OP_const2s: s->Printf("const2s(0x%4.4x) ", m_data.GetU16(&offset)); break; // 0x0b 1 2-byte constant |
| case DW_OP_const4u: s->Printf("const4u(0x%8.8x) ", m_data.GetU32(&offset)); break; // 0x0c 1 4-byte constant |
| case DW_OP_const4s: s->Printf("const4s(0x%8.8x) ", m_data.GetU32(&offset)); break; // 0x0d 1 4-byte constant |
| case DW_OP_const8u: s->Printf("const8u(0x%16.16llx) ", m_data.GetU64(&offset)); break; // 0x0e 1 8-byte constant |
| case DW_OP_const8s: s->Printf("const8s(0x%16.16llx) ", m_data.GetU64(&offset)); break; // 0x0f 1 8-byte constant |
| case DW_OP_constu: s->Printf("constu(0x%x) ", m_data.GetULEB128(&offset)); break; // 0x10 1 ULEB128 constant |
| case DW_OP_consts: s->Printf("consts(0x%x) ", m_data.GetSLEB128(&offset)); break; // 0x11 1 SLEB128 constant |
| case DW_OP_dup: s->PutCString("dup"); break; // 0x12 |
| case DW_OP_drop: s->PutCString("drop"); break; // 0x13 |
| case DW_OP_over: s->PutCString("over"); break; // 0x14 |
| case DW_OP_pick: s->Printf("pick(0x%2.2x) ", m_data.GetU8(&offset)); break; // 0x15 1 1-byte stack index |
| case DW_OP_swap: s->PutCString("swap"); break; // 0x16 |
| case DW_OP_rot: s->PutCString("rot"); break; // 0x17 |
| case DW_OP_xderef: s->PutCString("xderef"); break; // 0x18 |
| case DW_OP_abs: s->PutCString("abs"); break; // 0x19 |
| case DW_OP_and: s->PutCString("and"); break; // 0x1a |
| case DW_OP_div: s->PutCString("div"); break; // 0x1b |
| case DW_OP_minus: s->PutCString("minus"); break; // 0x1c |
| case DW_OP_mod: s->PutCString("mod"); break; // 0x1d |
| case DW_OP_mul: s->PutCString("mul"); break; // 0x1e |
| case DW_OP_neg: s->PutCString("neg"); break; // 0x1f |
| case DW_OP_not: s->PutCString("not"); break; // 0x20 |
| case DW_OP_or: s->PutCString("or"); break; // 0x21 |
| case DW_OP_plus: s->PutCString("plus"); break; // 0x22 |
| case DW_OP_plus_uconst: // 0x23 1 ULEB128 addend |
| s->Printf("plus_uconst(0x%x) ", m_data.GetULEB128(&offset)); |
| break; |
| |
| case DW_OP_shl: s->PutCString("shl"); break; // 0x24 |
| case DW_OP_shr: s->PutCString("shr"); break; // 0x25 |
| case DW_OP_shra: s->PutCString("shra"); break; // 0x26 |
| case DW_OP_xor: s->PutCString("xor"); break; // 0x27 |
| case DW_OP_skip: s->Printf("skip(0x%4.4x)", m_data.GetU16(&offset)); break; // 0x2f 1 signed 2-byte constant |
| case DW_OP_bra: s->Printf("bra(0x%4.4x)", m_data.GetU16(&offset)); break; // 0x28 1 signed 2-byte constant |
| case DW_OP_eq: s->PutCString("eq"); break; // 0x29 |
| case DW_OP_ge: s->PutCString("ge"); break; // 0x2a |
| case DW_OP_gt: s->PutCString("gt"); break; // 0x2b |
| case DW_OP_le: s->PutCString("le"); break; // 0x2c |
| case DW_OP_lt: s->PutCString("lt"); break; // 0x2d |
| case DW_OP_ne: s->PutCString("ne"); break; // 0x2e |
| |
| case DW_OP_lit0: // 0x30 |
| case DW_OP_lit1: // 0x31 |
| case DW_OP_lit2: // 0x32 |
| case DW_OP_lit3: // 0x33 |
| case DW_OP_lit4: // 0x34 |
| case DW_OP_lit5: // 0x35 |
| case DW_OP_lit6: // 0x36 |
| case DW_OP_lit7: // 0x37 |
| case DW_OP_lit8: // 0x38 |
| case DW_OP_lit9: // 0x39 |
| case DW_OP_lit10: // 0x3A |
| case DW_OP_lit11: // 0x3B |
| case DW_OP_lit12: // 0x3C |
| case DW_OP_lit13: // 0x3D |
| case DW_OP_lit14: // 0x3E |
| case DW_OP_lit15: // 0x3F |
| case DW_OP_lit16: // 0x40 |
| case DW_OP_lit17: // 0x41 |
| case DW_OP_lit18: // 0x42 |
| case DW_OP_lit19: // 0x43 |
| case DW_OP_lit20: // 0x44 |
| case DW_OP_lit21: // 0x45 |
| case DW_OP_lit22: // 0x46 |
| case DW_OP_lit23: // 0x47 |
| case DW_OP_lit24: // 0x48 |
| case DW_OP_lit25: // 0x49 |
| case DW_OP_lit26: // 0x4A |
| case DW_OP_lit27: // 0x4B |
| case DW_OP_lit28: // 0x4C |
| case DW_OP_lit29: // 0x4D |
| case DW_OP_lit30: // 0x4E |
| case DW_OP_lit31: s->Printf("lit%i", op - DW_OP_lit0); break; // 0x4f |
| |
| case DW_OP_reg0: // 0x50 |
| case DW_OP_reg1: // 0x51 |
| case DW_OP_reg2: // 0x52 |
| case DW_OP_reg3: // 0x53 |
| case DW_OP_reg4: // 0x54 |
| case DW_OP_reg5: // 0x55 |
| case DW_OP_reg6: // 0x56 |
| case DW_OP_reg7: // 0x57 |
| case DW_OP_reg8: // 0x58 |
| case DW_OP_reg9: // 0x59 |
| case DW_OP_reg10: // 0x5A |
| case DW_OP_reg11: // 0x5B |
| case DW_OP_reg12: // 0x5C |
| case DW_OP_reg13: // 0x5D |
| case DW_OP_reg14: // 0x5E |
| case DW_OP_reg15: // 0x5F |
| case DW_OP_reg16: // 0x60 |
| case DW_OP_reg17: // 0x61 |
| case DW_OP_reg18: // 0x62 |
| case DW_OP_reg19: // 0x63 |
| case DW_OP_reg20: // 0x64 |
| case DW_OP_reg21: // 0x65 |
| case DW_OP_reg22: // 0x66 |
| case DW_OP_reg23: // 0x67 |
| case DW_OP_reg24: // 0x68 |
| case DW_OP_reg25: // 0x69 |
| case DW_OP_reg26: // 0x6A |
| case DW_OP_reg27: // 0x6B |
| case DW_OP_reg28: // 0x6C |
| case DW_OP_reg29: // 0x6D |
| case DW_OP_reg30: // 0x6E |
| case DW_OP_reg31: s->Printf("reg%i", op - DW_OP_reg0); break; // 0x6f |
| |
| 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: s->Printf("breg%i(0x%x)", op - DW_OP_breg0, m_data.GetULEB128(&offset)); break; |
| |
| case DW_OP_regx: // 0x90 1 ULEB128 register |
| s->Printf("regx(0x%x)", m_data.GetULEB128(&offset)); |
| break; |
| case DW_OP_fbreg: // 0x91 1 SLEB128 offset |
| s->Printf("fbreg(0x%x)",m_data.GetSLEB128(&offset)); |
| break; |
| case DW_OP_bregx: // 0x92 2 ULEB128 register followed by SLEB128 offset |
| s->Printf("bregx(0x%x, 0x%x)", m_data.GetULEB128(&offset), m_data.GetSLEB128(&offset)); |
| break; |
| case DW_OP_piece: // 0x93 1 ULEB128 size of piece addressed |
| s->Printf("piece(0x%x)", m_data.GetULEB128(&offset)); |
| break; |
| case DW_OP_deref_size: // 0x94 1 1-byte size of data retrieved |
| s->Printf("deref_size(0x%2.2x)", m_data.GetU8(&offset)); |
| break; |
| case DW_OP_xderef_size: // 0x95 1 1-byte size of data retrieved |
| s->Printf("xderef_size(0x%2.2x)", m_data.GetU8(&offset)); |
| break; |
| case DW_OP_nop: s->PutCString("nop"); break; // 0x96 |
| case DW_OP_push_object_address: s->PutCString("push_object_address"); break; // 0x97 DWARF3 |
| case DW_OP_call2: // 0x98 DWARF3 1 2-byte offset of DIE |
| s->Printf("call2(0x%4.4x)", m_data.GetU16(&offset)); |
| break; |
| case DW_OP_call4: // 0x99 DWARF3 1 4-byte offset of DIE |
| s->Printf("call4(0x%8.8x)", m_data.GetU32(&offset)); |
| break; |
| case DW_OP_call_ref: // 0x9a DWARF3 1 4- or 8-byte offset of DIE |
| s->Printf("call_ref(0x%8.8llx)", m_data.GetAddress(&offset)); |
| break; |
| // case DW_OP_form_tls_address: s << "form_tls_address"; break; // 0x9b DWARF3 |
| // case DW_OP_call_frame_cfa: s << "call_frame_cfa"; break; // 0x9c DWARF3 |
| // case DW_OP_bit_piece: // 0x9d DWARF3 2 |
| // s->Printf("bit_piece(0x%x, 0x%x)", m_data.GetULEB128(&offset), m_data.GetULEB128(&offset)); |
| // break; |
| // case DW_OP_lo_user: s->PutCString("lo_user"); break; // 0xe0 |
| // case DW_OP_hi_user: s->PutCString("hi_user"); break; // 0xff |
| case DW_OP_APPLE_extern: |
| s->Printf("extern(%u)", m_data.GetULEB128(&offset)); |
| break; |
| case DW_OP_APPLE_array_ref: |
| s->PutCString("array_ref"); |
| break; |
| case DW_OP_APPLE_uninit: |
| s->PutCString("uninit"); // 0xF0 |
| break; |
| case DW_OP_APPLE_assign: // 0xF1 - pops value off and assigns it to second item on stack (2nd item must have assignable context) |
| s->PutCString("assign"); |
| break; |
| case DW_OP_APPLE_address_of: // 0xF2 - gets the address of the top stack item (top item must be a variable, or have value_type that is an address already) |
| s->PutCString("address_of"); |
| break; |
| case DW_OP_APPLE_value_of: // 0xF3 - pops the value off the stack and pushes the value of that object (top item must be a variable, or expression local) |
| s->PutCString("value_of"); |
| break; |
| case DW_OP_APPLE_deref_type: // 0xF4 - gets the address of the top stack item (top item must be a variable, or a clang type) |
| s->PutCString("deref_type"); |
| break; |
| case DW_OP_APPLE_expr_local: // 0xF5 - ULEB128 expression local index |
| s->Printf("expr_local(%u)", m_data.GetULEB128(&offset)); |
| break; |
| case DW_OP_APPLE_constf: // 0xF6 - 1 byte float size, followed by constant float data |
| { |
| uint8_t float_length = m_data.GetU8(&offset); |
| s->Printf("constf(<%u> ", float_length); |
| m_data.Dump(s, offset, eFormatHex, float_length, 1, UINT32_MAX, DW_INVALID_ADDRESS, 0, 0); |
| s->PutChar(')'); |
| // Consume the float data |
| m_data.GetData(&offset, float_length); |
| } |
| break; |
| case DW_OP_APPLE_scalar_cast: |
| s->Printf("scalar_cast(%s)", Scalar::GetValueTypeAsCString ((Scalar::Type)m_data.GetU8(&offset))); |
| break; |
| case DW_OP_APPLE_clang_cast: |
| { |
| clang::Type *clang_type = (clang::Type *)m_data.GetMaxU64(&offset, sizeof(void*)); |
| s->Printf("clang_cast(%p)", clang_type); |
| } |
| break; |
| case DW_OP_APPLE_clear: |
| s->PutCString("clear"); |
| break; |
| case DW_OP_APPLE_error: // 0xFF - Stops expression evaluation and returns an error (no args) |
| s->PutCString("error"); |
| break; |
| } |
| } |
| } |
| |
| void |
| DWARFExpression::SetLocationListSlide (addr_t slide) |
| { |
| m_loclist_slide = slide; |
| } |
| |
| int |
| DWARFExpression::GetRegisterKind () |
| { |
| return m_reg_kind; |
| } |
| |
| void |
| DWARFExpression::SetRegisterKind (int reg_kind) |
| { |
| m_reg_kind = reg_kind; |
| } |
| |
| bool |
| DWARFExpression::IsLocationList() const |
| { |
| return m_loclist_slide != LLDB_INVALID_ADDRESS; |
| } |
| |
| void |
| DWARFExpression::GetDescription (Stream *s, lldb::DescriptionLevel level, addr_t location_list_base_addr) const |
| { |
| if (IsLocationList()) |
| { |
| // We have a location list |
| uint32_t offset = 0; |
| uint32_t count = 0; |
| addr_t curr_base_addr = location_list_base_addr; |
| while (m_data.ValidOffset(offset)) |
| { |
| lldb::addr_t begin_addr_offset = m_data.GetAddress(&offset); |
| lldb::addr_t end_addr_offset = m_data.GetAddress(&offset); |
| if (begin_addr_offset < end_addr_offset) |
| { |
| if (count > 0) |
| s->PutCString(", "); |
| VMRange addr_range(curr_base_addr + begin_addr_offset, curr_base_addr + end_addr_offset); |
| addr_range.Dump(s, 0, 8); |
| s->PutChar('{'); |
| uint32_t location_length = m_data.GetU16(&offset); |
| DumpLocation (s, offset, location_length, level); |
| s->PutChar('}'); |
| offset += location_length; |
| } |
| else if (begin_addr_offset == 0 && end_addr_offset == 0) |
| { |
| // The end of the location list is marked by both the start and end offset being zero |
| break; |
| } |
| else |
| { |
| if (m_data.GetAddressByteSize() == 4 && begin_addr_offset == 0xFFFFFFFFull || |
| m_data.GetAddressByteSize() == 8 && begin_addr_offset == 0xFFFFFFFFFFFFFFFFull) |
| { |
| curr_base_addr = end_addr_offset + location_list_base_addr; |
| // We have a new base address |
| if (count > 0) |
| s->PutCString(", "); |
| *s << "base_addr = " << end_addr_offset; |
| } |
| } |
| |
| count++; |
| } |
| } |
| else |
| { |
| // We have a normal location that contains DW_OP location opcodes |
| DumpLocation (s, 0, m_data.GetByteSize(), level); |
| } |
| } |
| |
| static bool |
| ReadRegisterValueAsScalar |
| ( |
| ExecutionContext *exe_ctx, |
| uint32_t reg_kind, |
| uint32_t reg_num, |
| Error *error_ptr, |
| Value &value |
| ) |
| { |
| if (exe_ctx && exe_ctx->frame) |
| { |
| RegisterContext *reg_context = exe_ctx->frame->GetRegisterContext(); |
| |
| if (reg_context == NULL) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat("No register context in frame.\n"); |
| } |
| else |
| { |
| uint32_t native_reg = reg_context->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num); |
| if (native_reg == LLDB_INVALID_REGNUM) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat("Unable to convert register kind=%u reg_num=%u to a native register number.\n", reg_kind, reg_num); |
| } |
| else |
| { |
| value.SetValueType (Value::eValueTypeScalar); |
| value.SetContext (Value::eContextTypeDCRegisterInfo, const_cast<RegisterInfo *>(reg_context->GetRegisterInfoAtIndex(native_reg))); |
| |
| if (reg_context->ReadRegisterValue (native_reg, value.GetScalar())) |
| return true; |
| |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat("Failed to read register %u.\n", native_reg); |
| } |
| } |
| } |
| else |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat("Invalid frame in execution context.\n"); |
| } |
| return false; |
| } |
| |
| //bool |
| //DWARFExpression::LocationListContainsLoadAddress (Process* process, const Address &addr) const |
| //{ |
| // return LocationListContainsLoadAddress(process, addr.GetLoadAddress(process)); |
| //} |
| // |
| //bool |
| //DWARFExpression::LocationListContainsLoadAddress (Process* process, addr_t load_addr) const |
| //{ |
| // if (load_addr == LLDB_INVALID_ADDRESS) |
| // return false; |
| // |
| // if (IsLocationList()) |
| // { |
| // uint32_t offset = 0; |
| // |
| // addr_t loc_list_base_addr = m_loclist_slide.GetLoadAddress(process); |
| // |
| // if (loc_list_base_addr == LLDB_INVALID_ADDRESS) |
| // return false; |
| // |
| // while (m_data.ValidOffset(offset)) |
| // { |
| // // We need to figure out what the value is for the location. |
| // addr_t lo_pc = m_data.GetAddress(&offset); |
| // addr_t hi_pc = m_data.GetAddress(&offset); |
| // if (lo_pc == 0 && hi_pc == 0) |
| // break; |
| // else |
| // { |
| // lo_pc += loc_list_base_addr; |
| // hi_pc += loc_list_base_addr; |
| // |
| // if (lo_pc <= load_addr && load_addr < hi_pc) |
| // return true; |
| // |
| // offset += m_data.GetU16(&offset); |
| // } |
| // } |
| // } |
| // return false; |
| //} |
| |
| bool |
| DWARFExpression::LocationListContainsAddress (lldb::addr_t loclist_base_addr, lldb::addr_t addr) const |
| { |
| if (addr == LLDB_INVALID_ADDRESS) |
| return false; |
| |
| if (IsLocationList()) |
| { |
| uint32_t offset = 0; |
| |
| if (loclist_base_addr == LLDB_INVALID_ADDRESS) |
| return false; |
| |
| while (m_data.ValidOffset(offset)) |
| { |
| // We need to figure out what the value is for the location. |
| addr_t lo_pc = m_data.GetAddress(&offset); |
| addr_t hi_pc = m_data.GetAddress(&offset); |
| if (lo_pc == 0 && hi_pc == 0) |
| break; |
| else |
| { |
| lo_pc += loclist_base_addr - m_loclist_slide; |
| hi_pc += loclist_base_addr - m_loclist_slide; |
| |
| if (lo_pc <= addr && addr < hi_pc) |
| return true; |
| |
| offset += m_data.GetU16(&offset); |
| } |
| } |
| } |
| return false; |
| } |
| |
| bool |
| DWARFExpression::Evaluate |
| ( |
| ExecutionContextScope *exe_scope, |
| clang::ASTContext *ast_context, |
| lldb::addr_t loclist_base_load_addr, |
| const Value* initial_value_ptr, |
| Value& result, |
| Error *error_ptr |
| ) const |
| { |
| ExecutionContext exe_ctx (exe_scope); |
| return Evaluate(&exe_ctx, ast_context, loclist_base_load_addr, initial_value_ptr, result, error_ptr); |
| } |
| |
| bool |
| DWARFExpression::Evaluate |
| ( |
| ExecutionContext *exe_ctx, |
| clang::ASTContext *ast_context, |
| lldb::addr_t loclist_base_load_addr, |
| const Value* initial_value_ptr, |
| Value& result, |
| Error *error_ptr |
| ) const |
| { |
| if (IsLocationList()) |
| { |
| uint32_t offset = 0; |
| addr_t pc = exe_ctx->frame->GetRegisterContext()->GetPC(); |
| |
| if (loclist_base_load_addr != LLDB_INVALID_ADDRESS) |
| { |
| if (pc == LLDB_INVALID_ADDRESS) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Invalid PC in frame."); |
| return false; |
| } |
| |
| addr_t curr_loclist_base_load_addr = loclist_base_load_addr; |
| |
| while (m_data.ValidOffset(offset)) |
| { |
| // We need to figure out what the value is for the location. |
| addr_t lo_pc = m_data.GetAddress(&offset); |
| addr_t hi_pc = m_data.GetAddress(&offset); |
| if (lo_pc == 0 && hi_pc == 0) |
| { |
| break; |
| } |
| else |
| { |
| lo_pc += curr_loclist_base_load_addr - m_loclist_slide; |
| hi_pc += curr_loclist_base_load_addr - m_loclist_slide; |
| |
| uint16_t length = m_data.GetU16(&offset); |
| |
| if (length > 0 && lo_pc <= pc && pc < hi_pc) |
| { |
| return DWARFExpression::Evaluate (exe_ctx, ast_context, m_data, m_expr_locals, m_decl_map, offset, length, m_reg_kind, initial_value_ptr, result, error_ptr); |
| } |
| offset += length; |
| } |
| } |
| } |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat("Out of scope."); |
| return false; |
| } |
| |
| // Not a location list, just a single expression. |
| return DWARFExpression::Evaluate (exe_ctx, ast_context, m_data, m_expr_locals, m_decl_map, 0, m_data.GetByteSize(), m_reg_kind, initial_value_ptr, result, error_ptr); |
| } |
| |
| |
| |
| bool |
| DWARFExpression::Evaluate |
| ( |
| ExecutionContext *exe_ctx, |
| clang::ASTContext *ast_context, |
| const DataExtractor& opcodes, |
| ClangExpressionVariableList *expr_locals, |
| ClangExpressionDeclMap *decl_map, |
| const uint32_t opcodes_offset, |
| const uint32_t opcodes_length, |
| const uint32_t reg_kind, |
| const Value* initial_value_ptr, |
| Value& result, |
| Error *error_ptr |
| ) |
| { |
| std::vector<Value> stack; |
| |
| if (initial_value_ptr) |
| stack.push_back(*initial_value_ptr); |
| |
| uint32_t offset = opcodes_offset; |
| const uint32_t end_offset = opcodes_offset + opcodes_length; |
| Value tmp; |
| uint32_t reg_num; |
| |
| // Make sure all of the data is available in opcodes. |
| if (!opcodes.ValidOffsetForDataOfSize(opcodes_offset, opcodes_length)) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString ("Invalid offset and/or length for opcodes buffer."); |
| return false; |
| } |
| Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS); |
| |
| |
| while (opcodes.ValidOffset(offset) && offset < end_offset) |
| { |
| const uint32_t op_offset = offset; |
| const uint8_t op = opcodes.GetU8(&offset); |
| |
| if (log) |
| { |
| size_t count = stack.size(); |
| log->Printf("Stack before operation has %d values:", count); |
| for (size_t i=0; i<count; ++i) |
| { |
| StreamString new_value; |
| new_value.Printf("[%zu]", i); |
| stack[i].Dump(&new_value); |
| log->Printf(" %s", new_value.GetData()); |
| } |
| log->Printf("0x%8.8x: %s", op_offset, DW_OP_value_to_name(op)); |
| } |
| switch (op) |
| { |
| //---------------------------------------------------------------------- |
| // The DW_OP_addr operation has a single operand that encodes a machine |
| // address and whose size is the size of an address on the target machine. |
| //---------------------------------------------------------------------- |
| case DW_OP_addr: |
| stack.push_back(opcodes.GetAddress(&offset)); |
| stack.back().SetValueType (Value::eValueTypeFileAddress); |
| break; |
| |
| //---------------------------------------------------------------------- |
| // The DW_OP_addr_sect_offset4 is used for any location expressions in |
| // shared libraries that have a location like: |
| // DW_OP_addr(0x1000) |
| // If this address resides in a shared library, then this virtual |
| // address won't make sense when it is evaluated in the context of a |
| // running process where shared libraries have been slid. To account for |
| // this, this new address type where we can store the section pointer |
| // and a 4 byte offset. |
| //---------------------------------------------------------------------- |
| // case DW_OP_addr_sect_offset4: |
| // { |
| // result_type = eResultTypeFileAddress; |
| // lldb::Section *sect = (lldb::Section *)opcodes.GetMaxU64(&offset, sizeof(void *)); |
| // lldb::addr_t sect_offset = opcodes.GetU32(&offset); |
| // |
| // Address so_addr (sect, sect_offset); |
| // lldb::addr_t load_addr = so_addr.GetLoadAddress(); |
| // if (load_addr != LLDB_INVALID_ADDRESS) |
| // { |
| // // We successfully resolve a file address to a load |
| // // address. |
| // stack.push_back(load_addr); |
| // break; |
| // } |
| // else |
| // { |
| // // We were able |
| // if (error_ptr) |
| // error_ptr->SetErrorStringWithFormat ("Section %s in %s is not currently loaded.\n", sect->GetName().AsCString(), sect->GetModule()->GetFileSpec().GetFilename().AsCString()); |
| // return false; |
| // } |
| // } |
| // break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_deref |
| // OPERANDS: none |
| // DESCRIPTION: Pops the top stack entry and treats it as an address. |
| // The value retrieved from that address is pushed. The size of the |
| // data retrieved from the dereferenced address is the size of an |
| // address on the target machine. |
| //---------------------------------------------------------------------- |
| case DW_OP_deref: |
| { |
| Value::ValueType value_type = stack.back().GetValueType(); |
| switch (value_type) |
| { |
| case Value::eValueTypeHostAddress: |
| { |
| void *src = (void *)stack.back().GetScalar().ULongLong(); |
| intptr_t ptr; |
| ::memcpy (&ptr, src, sizeof(void *)); |
| stack.back().GetScalar() = ptr; |
| stack.back().ClearContext(); |
| } |
| break; |
| case Value::eValueTypeLoadAddress: |
| if (exe_ctx) |
| { |
| if (exe_ctx->process) |
| { |
| lldb::addr_t pointer_addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS); |
| uint8_t addr_bytes[sizeof(lldb::addr_t)]; |
| uint32_t addr_size = exe_ctx->process->GetAddressByteSize(); |
| Error error; |
| if (exe_ctx->process->ReadMemory(pointer_addr, &addr_bytes, addr_size, error) == addr_size) |
| { |
| DataExtractor addr_data(addr_bytes, sizeof(addr_bytes), exe_ctx->process->GetByteOrder(), addr_size); |
| uint32_t addr_data_offset = 0; |
| stack.back().GetScalar() = addr_data.GetPointer(&addr_data_offset); |
| stack.back().ClearContext(); |
| } |
| else |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("Failed to dereference pointer from 0x%llx for DW_OP_deref: %s\n", |
| pointer_addr, |
| error.AsCString()); |
| return false; |
| } |
| } |
| else |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("NULL process for DW_OP_deref.\n"); |
| return false; |
| } |
| } |
| else |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("NULL execution context for DW_OP_deref.\n"); |
| return false; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_deref_size |
| // OPERANDS: 1 |
| // 1 - uint8_t that specifies the size of the data to dereference. |
| // DESCRIPTION: Behaves like the DW_OP_deref operation: it pops the top |
| // stack entry and treats it as an address. The value retrieved from that |
| // address is pushed. In the DW_OP_deref_size operation, however, the |
| // size in bytes of the data retrieved from the dereferenced address is |
| // specified by the single operand. This operand is a 1-byte unsigned |
| // integral constant whose value may not be larger than the size of an |
| // address on the target machine. The data retrieved is zero extended |
| // to the size of an address on the target machine before being pushed |
| // on the expression stack. |
| //---------------------------------------------------------------------- |
| case DW_OP_deref_size: |
| if (error_ptr) |
| error_ptr->SetErrorString("Unimplemented opcode: DW_OP_deref_size."); |
| return false; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_xderef_size |
| // OPERANDS: 1 |
| // 1 - uint8_t that specifies the size of the data to dereference. |
| // DESCRIPTION: Behaves like the DW_OP_xderef operation: the entry at |
| // the top of the stack is treated as an address. The second stack |
| // entry is treated as an "address space identifier" for those |
| // architectures that support multiple address spaces. The top two |
| // stack elements are popped, a data item is retrieved through an |
| // implementation-defined address calculation and pushed as the new |
| // stack top. In the DW_OP_xderef_size operation, however, the size in |
| // bytes of the data retrieved from the dereferenced address is |
| // specified by the single operand. This operand is a 1-byte unsigned |
| // integral constant whose value may not be larger than the size of an |
| // address on the target machine. The data retrieved is zero extended |
| // to the size of an address on the target machine before being pushed |
| // on the expression stack. |
| //---------------------------------------------------------------------- |
| case DW_OP_xderef_size: |
| if (error_ptr) |
| error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef_size."); |
| return false; |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_xderef |
| // OPERANDS: none |
| // DESCRIPTION: Provides an extended dereference mechanism. The entry at |
| // the top of the stack is treated as an address. The second stack entry |
| // is treated as an "address space identifier" for those architectures |
| // that support multiple address spaces. The top two stack elements are |
| // popped, a data item is retrieved through an implementation-defined |
| // address calculation and pushed as the new stack top. The size of the |
| // data retrieved from the dereferenced address is the size of an address |
| // on the target machine. |
| //---------------------------------------------------------------------- |
| case DW_OP_xderef: |
| if (error_ptr) |
| error_ptr->SetErrorString("Unimplemented opcode: DW_OP_xderef."); |
| return false; |
| |
| //---------------------------------------------------------------------- |
| // All DW_OP_constXXX opcodes have a single operand as noted below: |
| // |
| // Opcode Operand 1 |
| // --------------- ---------------------------------------------------- |
| // DW_OP_const1u 1-byte unsigned integer constant |
| // DW_OP_const1s 1-byte signed integer constant |
| // DW_OP_const2u 2-byte unsigned integer constant |
| // DW_OP_const2s 2-byte signed integer constant |
| // DW_OP_const4u 4-byte unsigned integer constant |
| // DW_OP_const4s 4-byte signed integer constant |
| // DW_OP_const8u 8-byte unsigned integer constant |
| // DW_OP_const8s 8-byte signed integer constant |
| // DW_OP_constu unsigned LEB128 integer constant |
| // DW_OP_consts signed LEB128 integer constant |
| //---------------------------------------------------------------------- |
| case DW_OP_const1u : stack.push_back(( uint8_t)opcodes.GetU8(&offset)); break; |
| case DW_OP_const1s : stack.push_back(( int8_t)opcodes.GetU8(&offset)); break; |
| case DW_OP_const2u : stack.push_back((uint16_t)opcodes.GetU16(&offset)); break; |
| case DW_OP_const2s : stack.push_back(( int16_t)opcodes.GetU16(&offset)); break; |
| case DW_OP_const4u : stack.push_back((uint32_t)opcodes.GetU32(&offset)); break; |
| case DW_OP_const4s : stack.push_back(( int32_t)opcodes.GetU32(&offset)); break; |
| case DW_OP_const8u : stack.push_back((uint64_t)opcodes.GetU64(&offset)); break; |
| case DW_OP_const8s : stack.push_back(( int64_t)opcodes.GetU64(&offset)); break; |
| case DW_OP_constu : stack.push_back(opcodes.GetULEB128(&offset)); break; |
| case DW_OP_consts : stack.push_back(opcodes.GetSLEB128(&offset)); break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_dup |
| // OPERANDS: none |
| // DESCRIPTION: duplicates the value at the top of the stack |
| //---------------------------------------------------------------------- |
| case DW_OP_dup: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack empty for DW_OP_dup."); |
| return false; |
| } |
| else |
| stack.push_back(stack.back()); |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_drop |
| // OPERANDS: none |
| // DESCRIPTION: pops the value at the top of the stack |
| //---------------------------------------------------------------------- |
| case DW_OP_drop: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack empty for DW_OP_drop."); |
| return false; |
| } |
| else |
| stack.pop_back(); |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_over |
| // OPERANDS: none |
| // DESCRIPTION: Duplicates the entry currently second in the stack at |
| // the top of the stack. |
| //---------------------------------------------------------------------- |
| case DW_OP_over: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_over."); |
| return false; |
| } |
| else |
| stack.push_back(stack[stack.size() - 2]); |
| break; |
| |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_pick |
| // OPERANDS: uint8_t index into the current stack |
| // DESCRIPTION: The stack entry with the specified index (0 through 255, |
| // inclusive) is pushed on the stack |
| //---------------------------------------------------------------------- |
| case DW_OP_pick: |
| { |
| uint8_t pick_idx = opcodes.GetU8(&offset); |
| if (pick_idx < stack.size()) |
| stack.push_back(stack[pick_idx]); |
| else |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat("Index %u out of range for DW_OP_pick.\n", pick_idx); |
| return false; |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_swap |
| // OPERANDS: none |
| // DESCRIPTION: swaps the top two stack entries. The entry at the top |
| // of the stack becomes the second stack entry, and the second entry |
| // becomes the top of the stack |
| //---------------------------------------------------------------------- |
| case DW_OP_swap: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_swap."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.back() = stack[stack.size() - 2]; |
| stack[stack.size() - 2] = tmp; |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_rot |
| // OPERANDS: none |
| // DESCRIPTION: Rotates the first three stack entries. The entry at |
| // the top of the stack becomes the third stack entry, the second |
| // entry becomes the top of the stack, and the third entry becomes |
| // the second entry. |
| //---------------------------------------------------------------------- |
| case DW_OP_rot: |
| if (stack.size() < 3) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 3 items for DW_OP_rot."); |
| return false; |
| } |
| else |
| { |
| size_t last_idx = stack.size() - 1; |
| Value old_top = stack[last_idx]; |
| stack[last_idx] = stack[last_idx - 1]; |
| stack[last_idx - 1] = stack[last_idx - 2]; |
| stack[last_idx - 2] = old_top; |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_abs |
| // OPERANDS: none |
| // DESCRIPTION: pops the top stack entry, interprets it as a signed |
| // value and pushes its absolute value. If the absolute value can not be |
| // represented, the result is undefined. |
| //---------------------------------------------------------------------- |
| case DW_OP_abs: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_abs."); |
| return false; |
| } |
| else if (stack.back().ResolveValue(exe_ctx, ast_context).AbsoluteValue() == false) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Failed to take the absolute value of the first stack item."); |
| return false; |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_and |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values, performs a bitwise and |
| // operation on the two, and pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_and: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_and."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) & tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_div |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values, divides the former second |
| // entry by the former top of the stack using signed division, and |
| // pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_div: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_div."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| if (tmp.ResolveValue(exe_ctx, ast_context).IsZero()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Divide by zero."); |
| return false; |
| } |
| else |
| { |
| stack.pop_back(); |
| stack.back() = stack.back().ResolveValue(exe_ctx, ast_context) / tmp.ResolveValue(exe_ctx, ast_context); |
| if (!stack.back().ResolveValue(exe_ctx, ast_context).IsValid()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Divide failed."); |
| return false; |
| } |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_minus |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values, subtracts the former top |
| // of the stack from the former second entry, and pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_minus: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_minus."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) - tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_mod |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values and pushes the result of |
| // the calculation: former second stack entry modulo the former top of |
| // the stack. |
| //---------------------------------------------------------------------- |
| case DW_OP_mod: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_mod."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) % tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_mul |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack entries, multiplies them |
| // together, and pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_mul: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_mul."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) * tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_neg |
| // OPERANDS: none |
| // DESCRIPTION: pops the top stack entry, and pushes its negation. |
| //---------------------------------------------------------------------- |
| case DW_OP_neg: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_neg."); |
| return false; |
| } |
| else |
| { |
| if (stack.back().ResolveValue(exe_ctx, ast_context).UnaryNegate() == false) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Unary negate failed."); |
| return false; |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_not |
| // OPERANDS: none |
| // DESCRIPTION: pops the top stack entry, and pushes its bitwise |
| // complement |
| //---------------------------------------------------------------------- |
| case DW_OP_not: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_not."); |
| return false; |
| } |
| else |
| { |
| if (stack.back().ResolveValue(exe_ctx, ast_context).OnesComplement() == false) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Logical NOT failed."); |
| return false; |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_or |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack entries, performs a bitwise or |
| // operation on the two, and pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_or: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_or."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) | tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_plus |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack entries, adds them together, and |
| // pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_plus: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_plus."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) + tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_plus_uconst |
| // OPERANDS: none |
| // DESCRIPTION: pops the top stack entry, adds it to the unsigned LEB128 |
| // constant operand and pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_plus_uconst: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_plus_uconst."); |
| return false; |
| } |
| else |
| { |
| uint32_t uconst_value = opcodes.GetULEB128(&offset); |
| // Implicit conversion from a UINT to a Scalar... |
| stack.back().ResolveValue(exe_ctx, ast_context) += uconst_value; |
| if (!stack.back().ResolveValue(exe_ctx, ast_context).IsValid()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("DW_OP_plus_uconst failed."); |
| return false; |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_shl |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack entries, shifts the former |
| // second entry left by the number of bits specified by the former top |
| // of the stack, and pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_shl: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_shl."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) <<= tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_shr |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack entries, shifts the former second |
| // entry right logically (filling with zero bits) by the number of bits |
| // specified by the former top of the stack, and pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_shr: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_shr."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| if (stack.back().ResolveValue(exe_ctx, ast_context).ShiftRightLogical(tmp.ResolveValue(exe_ctx, ast_context)) == false) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("DW_OP_shr failed."); |
| return false; |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_shra |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack entries, shifts the former second |
| // entry right arithmetically (divide the magnitude by 2, keep the same |
| // sign for the result) by the number of bits specified by the former |
| // top of the stack, and pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_shra: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_shra."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) >>= tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_xor |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack entries, performs the bitwise |
| // exclusive-or operation on the two, and pushes the result. |
| //---------------------------------------------------------------------- |
| case DW_OP_xor: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_xor."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) ^ tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_skip |
| // OPERANDS: int16_t |
| // DESCRIPTION: An unconditional branch. Its single operand is a 2-byte |
| // signed integer constant. The 2-byte constant is the number of bytes |
| // of the DWARF expression to skip forward or backward from the current |
| // operation, beginning after the 2-byte constant. |
| //---------------------------------------------------------------------- |
| case DW_OP_skip: |
| { |
| int16_t skip_offset = (int16_t)opcodes.GetU16(&offset); |
| uint32_t new_offset = offset + skip_offset; |
| if (new_offset >= opcodes_offset && new_offset < end_offset) |
| offset = new_offset; |
| else |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Invalid opcode offset in DW_OP_skip."); |
| return false; |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_bra |
| // OPERANDS: int16_t |
| // DESCRIPTION: A conditional branch. Its single operand is a 2-byte |
| // signed integer constant. This operation pops the top of stack. If |
| // the value popped is not the constant 0, the 2-byte constant operand |
| // is the number of bytes of the DWARF expression to skip forward or |
| // backward from the current operation, beginning after the 2-byte |
| // constant. |
| //---------------------------------------------------------------------- |
| case DW_OP_bra: |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| int16_t bra_offset = (int16_t)opcodes.GetU16(&offset); |
| Scalar zero(0); |
| if (tmp.ResolveValue(exe_ctx, ast_context) != zero) |
| { |
| uint32_t new_offset = offset + bra_offset; |
| if (new_offset >= opcodes_offset && new_offset < end_offset) |
| offset = new_offset; |
| else |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Invalid opcode offset in DW_OP_bra."); |
| return false; |
| } |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_eq |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values, compares using the |
| // equals (==) operator. |
| // STACK RESULT: push the constant value 1 onto the stack if the result |
| // of the operation is true or the constant value 0 if the result of the |
| // operation is false. |
| //---------------------------------------------------------------------- |
| case DW_OP_eq: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_eq."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) == tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_ge |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values, compares using the |
| // greater than or equal to (>=) operator. |
| // STACK RESULT: push the constant value 1 onto the stack if the result |
| // of the operation is true or the constant value 0 if the result of the |
| // operation is false. |
| //---------------------------------------------------------------------- |
| case DW_OP_ge: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_ge."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) >= tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_gt |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values, compares using the |
| // greater than (>) operator. |
| // STACK RESULT: push the constant value 1 onto the stack if the result |
| // of the operation is true or the constant value 0 if the result of the |
| // operation is false. |
| //---------------------------------------------------------------------- |
| case DW_OP_gt: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_gt."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) > tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_le |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values, compares using the |
| // less than or equal to (<=) operator. |
| // STACK RESULT: push the constant value 1 onto the stack if the result |
| // of the operation is true or the constant value 0 if the result of the |
| // operation is false. |
| //---------------------------------------------------------------------- |
| case DW_OP_le: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_le."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) <= tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_lt |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values, compares using the |
| // less than (<) operator. |
| // STACK RESULT: push the constant value 1 onto the stack if the result |
| // of the operation is true or the constant value 0 if the result of the |
| // operation is false. |
| //---------------------------------------------------------------------- |
| case DW_OP_lt: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_lt."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) < tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_ne |
| // OPERANDS: none |
| // DESCRIPTION: pops the top two stack values, compares using the |
| // not equal (!=) operator. |
| // STACK RESULT: push the constant value 1 onto the stack if the result |
| // of the operation is true or the constant value 0 if the result of the |
| // operation is false. |
| //---------------------------------------------------------------------- |
| case DW_OP_ne: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_ne."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| stack.back().ResolveValue(exe_ctx, ast_context) = stack.back().ResolveValue(exe_ctx, ast_context) != tmp.ResolveValue(exe_ctx, ast_context); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_litn |
| // OPERANDS: none |
| // DESCRIPTION: encode the unsigned literal values from 0 through 31. |
| // STACK RESULT: push the unsigned literal constant value onto the top |
| // of the stack. |
| //---------------------------------------------------------------------- |
| 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: |
| stack.push_back(op - DW_OP_lit0); |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_regN |
| // OPERANDS: none |
| // DESCRIPTION: Push the value in register n on the top of the stack. |
| //---------------------------------------------------------------------- |
| 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_num = op - DW_OP_reg0; |
| |
| if (ReadRegisterValueAsScalar (exe_ctx, reg_kind, reg_num, error_ptr, tmp)) |
| stack.push_back(tmp); |
| else |
| return false; |
| } |
| break; |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_regx |
| // OPERANDS: |
| // ULEB128 literal operand that encodes the register. |
| // DESCRIPTION: Push the value in register on the top of the stack. |
| //---------------------------------------------------------------------- |
| case DW_OP_regx: |
| { |
| reg_num = opcodes.GetULEB128(&offset); |
| if (ReadRegisterValueAsScalar (exe_ctx, reg_kind, reg_num, error_ptr, tmp)) |
| stack.push_back(tmp); |
| else |
| return false; |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_bregN |
| // OPERANDS: |
| // SLEB128 offset from register N |
| // DESCRIPTION: Value is in memory at the address specified by register |
| // N plus an offset. |
| //---------------------------------------------------------------------- |
| 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_num = op - DW_OP_breg0; |
| |
| if (ReadRegisterValueAsScalar (exe_ctx, reg_kind, reg_num, error_ptr, tmp)) |
| { |
| int64_t breg_offset = opcodes.GetSLEB128(&offset); |
| tmp.ResolveValue(exe_ctx, ast_context) += (uint64_t)breg_offset; |
| stack.push_back(tmp); |
| stack.back().SetValueType (Value::eValueTypeLoadAddress); |
| } |
| else |
| return false; |
| } |
| break; |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_bregx |
| // OPERANDS: 2 |
| // ULEB128 literal operand that encodes the register. |
| // SLEB128 offset from register N |
| // DESCRIPTION: Value is in memory at the address specified by register |
| // N plus an offset. |
| //---------------------------------------------------------------------- |
| case DW_OP_bregx: |
| { |
| reg_num = opcodes.GetULEB128(&offset); |
| |
| if (ReadRegisterValueAsScalar (exe_ctx, reg_kind, reg_num, error_ptr, tmp)) |
| { |
| int64_t breg_offset = opcodes.GetSLEB128(&offset); |
| tmp.ResolveValue(exe_ctx, ast_context) += (uint64_t)breg_offset; |
| stack.push_back(tmp); |
| stack.back().SetValueType (Value::eValueTypeLoadAddress); |
| } |
| else |
| return false; |
| } |
| break; |
| |
| case DW_OP_fbreg: |
| if (exe_ctx && exe_ctx->frame) |
| { |
| Scalar value; |
| if (exe_ctx->frame->GetFrameBaseValue(value, error_ptr)) |
| { |
| int64_t fbreg_offset = opcodes.GetSLEB128(&offset); |
| value += fbreg_offset; |
| stack.push_back(value); |
| stack.back().SetValueType (Value::eValueTypeLoadAddress); |
| } |
| else |
| return false; |
| } |
| else |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString ("Invalid stack frame in context for DW_OP_fbreg opcode."); |
| return false; |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_nop |
| // OPERANDS: none |
| // DESCRIPTION: A place holder. It has no effect on the location stack |
| // or any of its values. |
| //---------------------------------------------------------------------- |
| case DW_OP_nop: |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_piece |
| // OPERANDS: 1 |
| // ULEB128: byte size of the piece |
| // DESCRIPTION: The operand describes the size in bytes of the piece of |
| // the object referenced by the DWARF expression whose result is at the |
| // top of the stack. If the piece is located in a register, but does not |
| // occupy the entire register, the placement of the piece within that |
| // register is defined by the ABI. |
| // |
| // Many compilers store a single variable in sets of registers, or store |
| // a variable partially in memory and partially in registers. |
| // DW_OP_piece provides a way of describing how large a part of a |
| // variable a particular DWARF expression refers to. |
| //---------------------------------------------------------------------- |
| case DW_OP_piece: |
| if (error_ptr) |
| error_ptr->SetErrorString ("Unimplemented opcode DW_OP_piece."); |
| return false; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_push_object_address |
| // OPERANDS: none |
| // DESCRIPTION: Pushes the address of the object currently being |
| // evaluated as part of evaluation of a user presented expression. |
| // This object may correspond to an independent variable described by |
| // its own DIE or it may be a component of an array, structure, or class |
| // whose address has been dynamically determined by an earlier step |
| // during user expression evaluation. |
| //---------------------------------------------------------------------- |
| case DW_OP_push_object_address: |
| if (error_ptr) |
| error_ptr->SetErrorString ("Unimplemented opcode DW_OP_push_object_address."); |
| return false; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_call2 |
| // OPERANDS: |
| // uint16_t compile unit relative offset of a DIE |
| // DESCRIPTION: Performs subroutine calls during evaluation |
| // of a DWARF expression. The operand is the 2-byte unsigned offset |
| // of a debugging information entry in the current compilation unit. |
| // |
| // Operand interpretation is exactly like that for DW_FORM_ref2. |
| // |
| // This operation transfers control of DWARF expression evaluation |
| // to the DW_AT_location attribute of the referenced DIE. If there is |
| // no such attribute, then there is no effect. Execution of the DWARF |
| // expression of a DW_AT_location attribute may add to and/or remove from |
| // values on the stack. Execution returns to the point following the call |
| // when the end of the attribute is reached. Values on the stack at the |
| // time of the call may be used as parameters by the called expression |
| // and values left on the stack by the called expression may be used as |
| // return values by prior agreement between the calling and called |
| // expressions. |
| //---------------------------------------------------------------------- |
| case DW_OP_call2: |
| if (error_ptr) |
| error_ptr->SetErrorString ("Unimplemented opcode DW_OP_call2."); |
| return false; |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_call4 |
| // OPERANDS: 1 |
| // uint32_t compile unit relative offset of a DIE |
| // DESCRIPTION: Performs a subroutine call during evaluation of a DWARF |
| // expression. For DW_OP_call4, the operand is a 4-byte unsigned offset |
| // of a debugging information entry in the current compilation unit. |
| // |
| // Operand interpretation DW_OP_call4 is exactly like that for |
| // DW_FORM_ref4. |
| // |
| // This operation transfers control of DWARF expression evaluation |
| // to the DW_AT_location attribute of the referenced DIE. If there is |
| // no such attribute, then there is no effect. Execution of the DWARF |
| // expression of a DW_AT_location attribute may add to and/or remove from |
| // values on the stack. Execution returns to the point following the call |
| // when the end of the attribute is reached. Values on the stack at the |
| // time of the call may be used as parameters by the called expression |
| // and values left on the stack by the called expression may be used as |
| // return values by prior agreement between the calling and called |
| // expressions. |
| //---------------------------------------------------------------------- |
| case DW_OP_call4: |
| if (error_ptr) |
| error_ptr->SetErrorString ("Unimplemented opcode DW_OP_call4."); |
| return false; |
| |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_call_ref |
| // OPERANDS: |
| // uint32_t absolute DIE offset for 32-bit DWARF or a uint64_t |
| // absolute DIE offset for 64 bit DWARF. |
| // DESCRIPTION: Performs a subroutine call during evaluation of a DWARF |
| // expression. Takes a single operand. In the 32-bit DWARF format, the |
| // operand is a 4-byte unsigned value; in the 64-bit DWARF format, it |
| // is an 8-byte unsigned value. The operand is used as the offset of a |
| // debugging information entry in a .debug_info section which may be |
| // contained in a shared object for executable other than that |
| // containing the operator. For references from one shared object or |
| // executable to another, the relocation must be performed by the |
| // consumer. |
| // |
| // Operand interpretation of DW_OP_call_ref is exactly like that for |
| // DW_FORM_ref_addr. |
| // |
| // This operation transfers control of DWARF expression evaluation |
| // to the DW_AT_location attribute of the referenced DIE. If there is |
| // no such attribute, then there is no effect. Execution of the DWARF |
| // expression of a DW_AT_location attribute may add to and/or remove from |
| // values on the stack. Execution returns to the point following the call |
| // when the end of the attribute is reached. Values on the stack at the |
| // time of the call may be used as parameters by the called expression |
| // and values left on the stack by the called expression may be used as |
| // return values by prior agreement between the calling and called |
| // expressions. |
| //---------------------------------------------------------------------- |
| case DW_OP_call_ref: |
| if (error_ptr) |
| error_ptr->SetErrorString ("Unimplemented opcode DW_OP_call_ref."); |
| return false; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_array_ref |
| // OPERANDS: none |
| // DESCRIPTION: Pops a value off the stack and uses it as the array |
| // index. Pops a second value off the stack and uses it as the array |
| // itself. Pushes a value onto the stack representing the element of |
| // the array specified by the index. |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_array_ref: |
| { |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_APPLE_array_ref."); |
| return false; |
| } |
| |
| Value index_val = stack.back(); |
| stack.pop_back(); |
| Value array_val = stack.back(); |
| stack.pop_back(); |
| |
| Scalar &index_scalar = index_val.ResolveValue(exe_ctx, ast_context); |
| int64_t index = index_scalar.SLongLong(LONG_LONG_MAX); |
| |
| if (index == LONG_LONG_MAX) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Invalid array index."); |
| return false; |
| } |
| |
| if (array_val.GetContextType() != Value::eContextTypeOpaqueClangQualType) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Arrays without Clang types are unhandled at this time."); |
| return false; |
| } |
| |
| if (array_val.GetValueType() != Value::eValueTypeLoadAddress && |
| array_val.GetValueType() != Value::eValueTypeHostAddress) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Array must be stored in memory."); |
| return false; |
| } |
| |
| void *array_type = array_val.GetClangType(); |
| |
| void *member_type; |
| uint64_t size = 0; |
| |
| if ((!ClangASTContext::IsPointerType(array_type, &member_type)) && |
| (!ClangASTContext::IsArrayType(array_type, &member_type, &size))) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Array reference from something that is neither a pointer nor an array."); |
| return false; |
| } |
| |
| if (size && (index >= size || index < 0)) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat("Out of bounds array access. %lld is not in [0, %llu]", index, size); |
| return false; |
| } |
| |
| uint64_t member_bit_size = ClangASTType::GetClangTypeBitWidth(ast_context, member_type); |
| uint64_t member_bit_align = ClangASTType::GetTypeBitAlign(ast_context, member_type); |
| uint64_t member_bit_incr = ((member_bit_size + member_bit_align - 1) / member_bit_align) * member_bit_align; |
| if (member_bit_incr % 8) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat("Array increment is not byte aligned", index, size); |
| return false; |
| } |
| int64_t member_offset = (int64_t)(member_bit_incr / 8) * index; |
| |
| Value member; |
| |
| member.SetContext(Value::eContextTypeOpaqueClangQualType, member_type); |
| member.SetValueType(array_val.GetValueType()); |
| |
| addr_t array_base = (addr_t)array_val.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); |
| addr_t member_loc = array_base + member_offset; |
| member.GetScalar() = (uint64_t)member_loc; |
| |
| stack.push_back(member); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_uninit |
| // OPERANDS: none |
| // DESCRIPTION: Lets us know that the value is currently not initialized |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_uninit: |
| //return eResultTypeErrorUninitialized; |
| break; // Ignore this as we have seen cases where this value is incorrectly added |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_assign |
| // OPERANDS: none |
| // DESCRIPTION: Pops a value off of the stack and assigns it to the next |
| // item on the stack which must be something assignable (inferior |
| // Variable, inferior Type with address, inferior register, or |
| // expression local variable. |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_assign: |
| if (stack.size() < 2) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 2 items for DW_OP_APPLE_assign."); |
| return false; |
| } |
| else |
| { |
| tmp = stack.back(); |
| stack.pop_back(); |
| Value::ContextType context_type = stack.back().GetContextType(); |
| StreamString new_value(Stream::eBinary, 4, eByteOrderHost); |
| switch (context_type) |
| { |
| case Value::eContextTypeOpaqueClangQualType: |
| { |
| void *clang_type = stack.back().GetClangType(); |
| |
| if (ClangASTContext::IsAggregateType (clang_type)) |
| { |
| Value::ValueType source_value_type = tmp.GetValueType(); |
| Value::ValueType target_value_type = stack.back().GetValueType(); |
| |
| addr_t source_addr = (addr_t)tmp.GetScalar().ULongLong(); |
| addr_t target_addr = (addr_t)stack.back().GetScalar().ULongLong(); |
| |
| size_t byte_size = (ClangASTType::GetClangTypeBitWidth(ast_context, clang_type) + 7) / 8; |
| |
| switch (source_value_type) |
| { |
| case Value::eValueTypeLoadAddress: |
| switch (target_value_type) |
| { |
| case Value::eValueTypeLoadAddress: |
| { |
| DataBufferHeap data; |
| data.SetByteSize(byte_size); |
| |
| Error error; |
| if (exe_ctx->process->ReadMemory (source_addr, data.GetBytes(), byte_size, error) != byte_size) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("Couldn't read a composite type from the target: %s", error.AsCString()); |
| return false; |
| } |
| |
| if (exe_ctx->process->WriteMemory (target_addr, data.GetBytes(), byte_size, error) != byte_size) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("Couldn't write a composite type to the target: %s", error.AsCString()); |
| return false; |
| } |
| } |
| break; |
| case Value::eValueTypeHostAddress: |
| if (exe_ctx->process->GetByteOrder() != Host::GetByteOrder()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("Copy of composite types between incompatible byte orders is unimplemented"); |
| return false; |
| } |
| else |
| { |
| Error error; |
| if (exe_ctx->process->ReadMemory (source_addr, (uint8_t*)target_addr, byte_size, error) != byte_size) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("Couldn't read a composite type from the target: %s", error.AsCString()); |
| return false; |
| } |
| } |
| break; |
| default: |
| return false; |
| } |
| break; |
| case Value::eValueTypeHostAddress: |
| switch (target_value_type) |
| { |
| case Value::eValueTypeLoadAddress: |
| if (exe_ctx->process->GetByteOrder() != Host::GetByteOrder()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("Copy of composite types between incompatible byte orders is unimplemented"); |
| return false; |
| } |
| else |
| { |
| Error error; |
| if (exe_ctx->process->WriteMemory (target_addr, (uint8_t*)source_addr, byte_size, error) != byte_size) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("Couldn't write a composite type to the target: %s", error.AsCString()); |
| return false; |
| } |
| } |
| case Value::eValueTypeHostAddress: |
| memcpy ((uint8_t*)target_addr, (uint8_t*)source_addr, byte_size); |
| break; |
| default: |
| return false; |
| } |
| } |
| } |
| else |
| { |
| if (!ClangASTType::SetValueFromScalar (ast_context, |
| clang_type, |
| tmp.ResolveValue(exe_ctx, ast_context), |
| new_value)) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("Couldn't extract a value from an integral type.\n"); |
| return false; |
| } |
| |
| Value::ValueType value_type = stack.back().GetValueType(); |
| |
| switch (value_type) |
| { |
| case Value::eValueTypeLoadAddress: |
| case Value::eValueTypeHostAddress: |
| { |
| lldb::AddressType address_type = (value_type == Value::eValueTypeLoadAddress ? eAddressTypeLoad : eAddressTypeHost); |
| lldb::addr_t addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS); |
| if (!ClangASTType::WriteToMemory (ast_context, |
| clang_type, |
| exe_ctx, |
| addr, |
| address_type, |
| new_value)) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("Failed to write value to memory at 0x%llx.\n", addr); |
| return false; |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| } |
| break; |
| |
| default: |
| if (error_ptr) |
| error_ptr->SetErrorString ("Assign failed."); |
| return false; |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_address_of |
| // OPERANDS: none |
| // DESCRIPTION: Pops a value off of the stack and pushed its address. |
| // The top item on the stack must be a variable, or already be a memory |
| // location. |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_address_of: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_APPLE_address_of."); |
| return false; |
| } |
| else |
| { |
| Value::ValueType value_type = stack.back().GetValueType(); |
| switch (value_type) |
| { |
| default: |
| case Value::eValueTypeScalar: // raw scalar value |
| if (error_ptr) |
| error_ptr->SetErrorString("Top stack item isn't a memory based object."); |
| return false; |
| |
| case Value::eValueTypeLoadAddress: // load address value |
| case Value::eValueTypeFileAddress: // file address value |
| case Value::eValueTypeHostAddress: // host address value (for memory in the process that is using liblldb) |
| // Taking the address of an object reduces it to the address |
| // of the value and removes any extra context it had. |
| //stack.back().SetValueType(Value::eValueTypeScalar); |
| stack.back().ClearContext(); |
| break; |
| } |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_value_of |
| // OPERANDS: none |
| // DESCRIPTION: Pops a value off of the stack and pushed its value. |
| // The top item on the stack must be a variable, expression variable. |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_value_of: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 1 items for DW_OP_APPLE_value_of."); |
| return false; |
| } |
| else if (!stack.back().ValueOf(exe_ctx, ast_context)) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString ("Top stack item isn't a valid candidate for DW_OP_APPLE_value_of."); |
| return false; |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_deref_type |
| // OPERANDS: none |
| // DESCRIPTION: gets the value pointed to by the top stack item |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_deref_type: |
| { |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 1 items for DW_OP_APPLE_deref_type."); |
| return false; |
| } |
| |
| tmp = stack.back(); |
| stack.pop_back(); |
| |
| if (tmp.GetContextType() != Value::eContextTypeOpaqueClangQualType) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Item at top of expression stack must have a Clang type"); |
| return false; |
| } |
| |
| void *ptr_type = tmp.GetClangType(); |
| void *target_type; |
| |
| if (!ClangASTContext::IsPointerType(ptr_type, &target_type)) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Dereferencing a non-pointer type"); |
| return false; |
| } |
| |
| // TODO do we want all pointers to be dereferenced as load addresses? |
| Value::ValueType value_type = tmp.GetValueType(); |
| |
| tmp.ResolveValue(exe_ctx, ast_context); |
| |
| tmp.SetValueType(value_type); |
| tmp.SetContext(Value::eContextTypeOpaqueClangQualType, target_type); |
| |
| stack.push_back(tmp); |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_expr_local |
| // OPERANDS: ULEB128 |
| // DESCRIPTION: pushes the expression local variable index onto the |
| // stack and set the appropriate context so we know the stack item is |
| // an expression local variable index. |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_expr_local: |
| { |
| /* |
| uint32_t idx = opcodes.GetULEB128(&offset); |
| if (expr_locals == NULL) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_expr_local(%u) opcode encountered with no local variable list.\n", idx); |
| return false; |
| } |
| Value *expr_local_variable = expr_locals->GetVariableAtIndex(idx); |
| if (expr_local_variable == NULL) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_expr_local(%u) with invalid index %u.\n", idx, idx); |
| return false; |
| } |
| Value *proxy = expr_local_variable->CreateProxy(); |
| stack.push_back(*proxy); |
| delete proxy; |
| //stack.back().SetContext (Value::eContextTypeOpaqueClangQualType, expr_local_variable->GetClangType()); |
| */ |
| } |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_extern |
| // OPERANDS: ULEB128 |
| // DESCRIPTION: pushes a proxy for the extern object index onto the |
| // stack. |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_extern: |
| { |
| /* |
| uint32_t idx = opcodes.GetULEB128(&offset); |
| if (!decl_map) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_extern(%u) opcode encountered with no decl map.\n", idx); |
| return false; |
| } |
| Value *extern_var = decl_map->GetValueForIndex(idx); |
| if (!extern_var) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_extern(%u) with invalid index %u.\n", idx, idx); |
| return false; |
| } |
| Value *proxy = extern_var->CreateProxy(); |
| stack.push_back(*proxy); |
| delete proxy; |
| */ |
| } |
| break; |
| |
| case DW_OP_APPLE_scalar_cast: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_APPLE_scalar_cast."); |
| return false; |
| } |
| else |
| { |
| // Simple scalar cast |
| if (!stack.back().ResolveValue(exe_ctx, ast_context).Cast((Scalar::Type)opcodes.GetU8(&offset))) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Cast failed."); |
| return false; |
| } |
| } |
| break; |
| |
| |
| case DW_OP_APPLE_clang_cast: |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString("Expression stack needs at least 1 item for DW_OP_APPLE_clang_cast."); |
| return false; |
| } |
| else |
| { |
| void *clang_type = (void *)opcodes.GetMaxU64(&offset, sizeof(void*)); |
| stack.back().SetContext (Value::eContextTypeOpaqueClangQualType, clang_type); |
| } |
| break; |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_constf |
| // OPERANDS: 1 byte float length, followed by that many bytes containing |
| // the constant float data. |
| // DESCRIPTION: Push a float value onto the expression stack. |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_constf: // 0xF6 - 1 byte float size, followed by constant float data |
| { |
| uint8_t float_length = opcodes.GetU8(&offset); |
| if (sizeof(float) == float_length) |
| tmp.ResolveValue(exe_ctx, ast_context) = opcodes.GetFloat (&offset); |
| else if (sizeof(double) == float_length) |
| tmp.ResolveValue(exe_ctx, ast_context) = opcodes.GetDouble (&offset); |
| else if (sizeof(long double) == float_length) |
| tmp.ResolveValue(exe_ctx, ast_context) = opcodes.GetLongDouble (&offset); |
| else |
| { |
| StreamString new_value; |
| opcodes.Dump(&new_value, offset, eFormatBytes, 1, float_length, UINT32_MAX, DW_INVALID_ADDRESS, 0, 0); |
| |
| if (error_ptr) |
| error_ptr->SetErrorStringWithFormat ("DW_OP_APPLE_constf(<%u> %s) unsupported float size.\n", float_length, new_value.GetData()); |
| return false; |
| } |
| tmp.SetValueType(Value::eValueTypeScalar); |
| tmp.ClearContext(); |
| stack.push_back(tmp); |
| } |
| break; |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_clear |
| // OPERANDS: none |
| // DESCRIPTION: Clears the expression stack. |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_clear: |
| stack.clear(); |
| break; |
| |
| //---------------------------------------------------------------------- |
| // OPCODE: DW_OP_APPLE_error |
| // OPERANDS: none |
| // DESCRIPTION: Pops a value off of the stack and pushed its value. |
| // The top item on the stack must be a variable, expression variable. |
| //---------------------------------------------------------------------- |
| case DW_OP_APPLE_error: // 0xFF - Stops expression evaluation and returns an error (no args) |
| if (error_ptr) |
| error_ptr->SetErrorString ("Generic error."); |
| return false; |
| } |
| } |
| |
| if (stack.empty()) |
| { |
| if (error_ptr) |
| error_ptr->SetErrorString ("Stack empty after evaluation."); |
| return false; |
| } |
| else if (log) |
| { |
| size_t count = stack.size(); |
| log->Printf("Stack after operation has %d values:", count); |
| for (size_t i=0; i<count; ++i) |
| { |
| StreamString new_value; |
| new_value.Printf("[%zu]", i); |
| stack[i].Dump(&new_value); |
| log->Printf(" %s", new_value.GetData()); |
| } |
| } |
| |
| result = stack.back(); |
| return true; // Return true on success |
| } |
| |