2010-06-09 00:52:24 +08:00
//===-- 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"
2010-09-14 10:20:48 +08:00
# include "lldb/Core/VMRange.h"
2010-06-09 00:52:24 +08:00
# include "lldb/Expression/ClangExpressionDeclMap.h"
# include "lldb/Expression/ClangExpressionVariable.h"
# include "lldb/Host/Host.h"
# include "lldb/lldb-private-log.h"
2010-07-22 06:12:05 +08:00
# include "lldb/Symbol/ClangASTType.h"
2010-06-09 00:52:24 +08:00
# 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 ) ,
2010-09-14 10:20:48 +08:00
m_loclist_slide ( LLDB_INVALID_ADDRESS ) ,
2010-06-09 00:52:24 +08:00
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 ) ,
2010-09-14 10:20:48 +08:00
m_loclist_slide ( rhs . m_loclist_slide ) ,
2010-06-09 00:52:24 +08:00
m_expr_locals ( rhs . m_expr_locals ) ,
m_decl_map ( rhs . m_decl_map )
{
}
2010-09-14 10:20:48 +08:00
DWARFExpression : : DWARFExpression ( const DataExtractor & data , uint32_t data_offset , uint32_t data_length ) :
2010-06-09 00:52:24 +08:00
m_data ( data , data_offset , data_length ) ,
m_reg_kind ( eRegisterKindDWARF ) ,
2010-09-14 10:20:48 +08:00
m_loclist_slide ( LLDB_INVALID_ADDRESS ) ,
2010-06-09 00:52:24 +08:00
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
2010-09-14 10:20:48 +08:00
DWARFExpression : : SetOpcodeData ( const DataExtractor & data )
2010-06-09 00:52:24 +08:00
{
m_data = data ;
}
void
2010-09-14 10:20:48 +08:00
DWARFExpression : : SetOpcodeData ( const DataExtractor & data , uint32_t data_offset , uint32_t data_length )
2010-06-09 00:52:24 +08:00
{
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 )
{
2010-07-10 04:39:50 +08:00
default :
break ;
2010-06-09 00:52:24 +08:00
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
2010-09-14 10:20:48 +08:00
DWARFExpression : : SetLocationListSlide ( addr_t slide )
2010-06-09 00:52:24 +08:00
{
2010-09-14 10:20:48 +08:00
m_loclist_slide = slide ;
2010-06-09 00:52:24 +08:00
}
int
DWARFExpression : : GetRegisterKind ( )
{
return m_reg_kind ;
}
void
DWARFExpression : : SetRegisterKind ( int reg_kind )
{
m_reg_kind = reg_kind ;
}
bool
DWARFExpression : : IsLocationList ( ) const
{
2010-09-14 10:20:48 +08:00
return m_loclist_slide ! = LLDB_INVALID_ADDRESS ;
2010-06-09 00:52:24 +08:00
}
void
2010-09-14 10:20:48 +08:00
DWARFExpression : : GetDescription ( Stream * s , lldb : : DescriptionLevel level , addr_t location_list_base_addr ) const
2010-06-09 00:52:24 +08:00
{
if ( IsLocationList ( ) )
{
// We have a location list
uint32_t offset = 0 ;
uint32_t count = 0 ;
2010-09-14 10:20:48 +08:00
addr_t curr_base_addr = location_list_base_addr ;
2010-06-09 00:52:24 +08:00
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 ( " , " ) ;
2010-09-14 10:20:48 +08:00
VMRange addr_range ( curr_base_addr + begin_addr_offset , curr_base_addr + end_addr_offset ) ;
addr_range . Dump ( s , 0 , 8 ) ;
2010-06-09 00:52:24 +08:00
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 )
{
2010-09-14 10:20:48 +08:00
curr_base_addr = end_addr_offset + location_list_base_addr ;
2010-06-09 00:52:24 +08:00
// 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 ;
}
2010-09-14 10:20:48 +08:00
//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;
//}
2010-08-25 05:05:24 +08:00
bool
2010-09-14 10:20:48 +08:00
DWARFExpression : : LocationListContainsAddress ( lldb : : addr_t loclist_base_addr , lldb : : addr_t addr ) const
2010-08-25 05:05:24 +08:00
{
2010-09-14 10:20:48 +08:00
if ( addr = = LLDB_INVALID_ADDRESS )
2010-08-25 05:05:24 +08:00
return false ;
2010-06-09 00:52:24 +08:00
if ( IsLocationList ( ) )
{
uint32_t offset = 0 ;
2010-09-14 10:20:48 +08:00
if ( loclist_base_addr = = LLDB_INVALID_ADDRESS )
2010-06-09 00:52:24 +08:00
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
{
2010-09-14 10:20:48 +08:00
lo_pc + = loclist_base_addr - m_loclist_slide ;
hi_pc + = loclist_base_addr - m_loclist_slide ;
2010-06-09 00:52:24 +08:00
2010-09-14 10:20:48 +08:00
if ( lo_pc < = addr & & addr < hi_pc )
2010-06-09 00:52:24 +08:00
return true ;
offset + = m_data . GetU16 ( & offset ) ;
}
}
}
return false ;
}
2010-08-25 05:05:24 +08:00
2010-06-09 00:52:24 +08:00
bool
DWARFExpression : : Evaluate
(
ExecutionContextScope * exe_scope ,
clang : : ASTContext * ast_context ,
2010-09-14 10:20:48 +08:00
lldb : : addr_t loclist_base_load_addr ,
2010-06-09 00:52:24 +08:00
const Value * initial_value_ptr ,
Value & result ,
Error * error_ptr
) const
{
ExecutionContext exe_ctx ( exe_scope ) ;
2010-09-14 10:20:48 +08:00
return Evaluate ( & exe_ctx , ast_context , loclist_base_load_addr , initial_value_ptr , result , error_ptr ) ;
2010-06-09 00:52:24 +08:00
}
bool
DWARFExpression : : Evaluate
(
ExecutionContext * exe_ctx ,
clang : : ASTContext * ast_context ,
2010-09-14 10:20:48 +08:00
lldb : : addr_t loclist_base_load_addr ,
2010-06-09 00:52:24 +08:00
const Value * initial_value_ptr ,
Value & result ,
Error * error_ptr
) const
{
if ( IsLocationList ( ) )
{
uint32_t offset = 0 ;
2010-08-25 05:05:24 +08:00
addr_t pc = exe_ctx - > frame - > GetRegisterContext ( ) - > GetPC ( ) ;
2010-06-09 00:52:24 +08:00
2010-09-14 10:20:48 +08:00
if ( loclist_base_load_addr ! = LLDB_INVALID_ADDRESS )
2010-06-09 00:52:24 +08:00
{
2010-09-14 10:20:48 +08:00
if ( pc = = LLDB_INVALID_ADDRESS )
2010-06-09 00:52:24 +08:00
{
2010-09-14 10:20:48 +08:00
if ( error_ptr )
error_ptr - > SetErrorString ( " Invalid PC in frame. " ) ;
return false ;
2010-06-09 00:52:24 +08:00
}
2010-09-14 10:20:48 +08:00
addr_t curr_loclist_base_load_addr = loclist_base_load_addr ;
2010-06-09 00:52:24 +08:00
2010-09-14 10:20:48 +08:00
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 )
2010-06-09 00:52:24 +08:00
{
2010-09-14 10:20:48 +08:00
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 ;
2010-06-09 00:52:24 +08:00
}
}
}
if ( error_ptr )
Added support for inlined stack frames being represented as real stack frames
which is now on by default. Frames are gotten from the unwinder as concrete
frames, then if inline frames are to be shown, extra information to track
and reconstruct these frames is cached with each Thread and exanded as needed.
I added an inline height as part of the lldb_private::StackID class, the class
that helps us uniquely identify stack frames. This allows for two frames to
shared the same call frame address, yet differ only in inline height.
Fixed setting breakpoint by address to not require addresses to resolve.
A quick example:
% cat main.cpp
% ./build/Debug/lldb test/stl/a.out
Current executable set to 'test/stl/a.out' (x86_64).
(lldb) breakpoint set --address 0x0000000100000d31
Breakpoint created: 1: address = 0x0000000100000d31, locations = 1
(lldb) r
Launching 'a.out' (x86_64)
(lldb) Process 38031 Stopped
* thread #1: tid = 0x2e03, pc = 0x0000000100000d31, where = a.out`main [inlined] std::string::_M_data() const at /usr/include/c++/4.2.1/bits/basic_string.h:280, stop reason = breakpoint 1.1, queue = com.apple.main-thread
277
278 _CharT*
279 _M_data() const
280 -> { return _M_dataplus._M_p; }
281
282 _CharT*
283 _M_data(_CharT* __p)
(lldb) bt
thread #1: tid = 0x2e03, stop reason = breakpoint 1.1, queue = com.apple.main-thread
frame #0: pc = 0x0000000100000d31, where = a.out`main [inlined] std::string::_M_data() const at /usr/include/c++/4.2.1/bits/basic_string.h:280
frame #1: pc = 0x0000000100000d31, where = a.out`main [inlined] std::string::_M_rep() const at /usr/include/c++/4.2.1/bits/basic_string.h:288
frame #2: pc = 0x0000000100000d31, where = a.out`main [inlined] std::string::size() const at /usr/include/c++/4.2.1/bits/basic_string.h:606
frame #3: pc = 0x0000000100000d31, where = a.out`main [inlined] operator<< <char, std::char_traits<char>, std::allocator<char> > at /usr/include/c++/4.2.1/bits/basic_string.h:2414
frame #4: pc = 0x0000000100000d31, where = a.out`main + 33 at /Volumes/work/gclayton/Documents/src/lldb/test/stl/main.cpp:14
frame #5: pc = 0x0000000100000d08, where = a.out`start + 52
Each inline frame contains only the variables that they contain and each inlined
stack frame is treated as a single entity.
llvm-svn: 111877
2010-08-24 08:45:41 +08:00
error_ptr - > SetErrorStringWithFormat ( " Out of scope. " ) ;
2010-06-09 00:52:24 +08:00
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 ( ) ;
2010-06-23 08:47:48 +08:00
log - > Printf ( " Stack before operation has %d values: " , count ) ;
2010-06-09 00:52:24 +08:00
for ( size_t i = 0 ; i < count ; + + i )
{
StreamString new_value ;
new_value . Printf ( " [%zu] " , i ) ;
stack [ i ] . Dump ( & new_value ) ;
2010-06-23 08:47:48 +08:00
log - > Printf ( " %s " , new_value . GetData ( ) ) ;
2010-06-09 00:52:24 +08:00
}
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
Added support for inlined stack frames being represented as real stack frames
which is now on by default. Frames are gotten from the unwinder as concrete
frames, then if inline frames are to be shown, extra information to track
and reconstruct these frames is cached with each Thread and exanded as needed.
I added an inline height as part of the lldb_private::StackID class, the class
that helps us uniquely identify stack frames. This allows for two frames to
shared the same call frame address, yet differ only in inline height.
Fixed setting breakpoint by address to not require addresses to resolve.
A quick example:
% cat main.cpp
% ./build/Debug/lldb test/stl/a.out
Current executable set to 'test/stl/a.out' (x86_64).
(lldb) breakpoint set --address 0x0000000100000d31
Breakpoint created: 1: address = 0x0000000100000d31, locations = 1
(lldb) r
Launching 'a.out' (x86_64)
(lldb) Process 38031 Stopped
* thread #1: tid = 0x2e03, pc = 0x0000000100000d31, where = a.out`main [inlined] std::string::_M_data() const at /usr/include/c++/4.2.1/bits/basic_string.h:280, stop reason = breakpoint 1.1, queue = com.apple.main-thread
277
278 _CharT*
279 _M_data() const
280 -> { return _M_dataplus._M_p; }
281
282 _CharT*
283 _M_data(_CharT* __p)
(lldb) bt
thread #1: tid = 0x2e03, stop reason = breakpoint 1.1, queue = com.apple.main-thread
frame #0: pc = 0x0000000100000d31, where = a.out`main [inlined] std::string::_M_data() const at /usr/include/c++/4.2.1/bits/basic_string.h:280
frame #1: pc = 0x0000000100000d31, where = a.out`main [inlined] std::string::_M_rep() const at /usr/include/c++/4.2.1/bits/basic_string.h:288
frame #2: pc = 0x0000000100000d31, where = a.out`main [inlined] std::string::size() const at /usr/include/c++/4.2.1/bits/basic_string.h:606
frame #3: pc = 0x0000000100000d31, where = a.out`main [inlined] operator<< <char, std::char_traits<char>, std::allocator<char> > at /usr/include/c++/4.2.1/bits/basic_string.h:2414
frame #4: pc = 0x0000000100000d31, where = a.out`main + 33 at /Volumes/work/gclayton/Documents/src/lldb/test/stl/main.cpp:14
frame #5: pc = 0x0000000100000d08, where = a.out`start + 52
Each inline frame contains only the variables that they contain and each inlined
stack frame is treated as a single entity.
llvm-svn: 111877
2010-08-24 08:45:41 +08:00
// entry is treated as an "address space identifier" for those
2010-06-09 00:52:24 +08:00
// 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 . GetOpaqueClangQualType ( ) ;
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 ;
}
2010-08-03 08:35:52 +08:00
uint64_t member_bit_size = ClangASTType : : GetClangTypeBitWidth ( ast_context , member_type ) ;
uint64_t member_bit_align = ClangASTType : : GetTypeBitAlign ( ast_context , member_type ) ;
2010-06-09 00:52:24 +08:00
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 ( ) . GetOpaqueClangQualType ( ) ;
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 ( ) ;
2010-08-03 08:35:52 +08:00
size_t byte_size = ( ClangASTType : : GetClangTypeBitWidth ( ast_context , clang_type ) + 7 ) / 8 ;
2010-06-09 00:52:24 +08:00
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
{
2010-07-22 06:12:05 +08:00
if ( ! ClangASTType : : SetValueFromScalar ( ast_context ,
clang_type ,
tmp . ResolveValue ( exe_ctx , ast_context ) ,
new_value ) )
2010-06-09 00:52:24 +08:00
{
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 ) ;
2010-07-22 06:12:05 +08:00
if ( ! ClangASTType : : WriteToMemory ( ast_context ,
clang_type ,
exe_ctx ,
addr ,
address_type ,
new_value ) )
2010-06-09 00:52:24 +08:00
{
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 . GetOpaqueClangQualType ( ) ;
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 :
{
2010-08-20 09:02:30 +08:00
/*
2010-06-09 00:52:24 +08:00
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->GetOpaqueClangQualType());
2010-08-20 09:02:30 +08:00
*/
2010-06-09 00:52:24 +08:00
}
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 :
{
2010-08-24 07:09:38 +08:00
/*
2010-06-09 00:52:24 +08:00
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 ;
2010-08-24 07:09:38 +08:00
*/
2010-06-09 00:52:24 +08:00
}
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 ( ) ;
2010-06-23 08:47:48 +08:00
log - > Printf ( " Stack after operation has %d values: " , count ) ;
2010-06-09 00:52:24 +08:00
for ( size_t i = 0 ; i < count ; + + i )
{
StreamString new_value ;
new_value . Printf ( " [%zu] " , i ) ;
stack [ i ] . Dump ( & new_value ) ;
2010-06-23 08:47:48 +08:00
log - > Printf ( " %s " , new_value . GetData ( ) ) ;
2010-06-09 00:52:24 +08:00
}
}
result = stack . back ( ) ;
return true ; // Return true on success
}
