ValueObjectVariable.cpp revision aed588178b54d221ef1784862adeb5262d3612f2
1//===-- ValueObjectVariable.cpp ---------------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10 11#include "lldb/Core/ValueObjectVariable.h" 12 13// C Includes 14// C++ Includes 15// Other libraries and framework includes 16// Project includes 17#include "lldb/Core/Module.h" 18#include "lldb/Core/ValueObjectList.h" 19#include "lldb/Core/Value.h" 20 21#include "lldb/Symbol/ObjectFile.h" 22#include "lldb/Symbol/SymbolContext.h" 23#include "lldb/Symbol/Type.h" 24#include "lldb/Symbol/Variable.h" 25 26#include "lldb/Target/ExecutionContext.h" 27#include "lldb/Target/Process.h" 28#include "lldb/Target/RegisterContext.h" 29#include "lldb/Target/Target.h" 30#include "lldb/Target/Thread.h" 31 32 33using namespace lldb_private; 34 35ValueObjectVariable::ValueObjectVariable (const lldb::VariableSP &var_sp) : 36 ValueObject(), 37 m_variable_sp(var_sp) 38{ 39 // Do not attempt to construct one of these objects with no variable! 40 assert (m_variable_sp.get() != NULL); 41 m_name = var_sp->GetName(); 42} 43 44ValueObjectVariable::~ValueObjectVariable() 45{ 46} 47 48void * 49ValueObjectVariable::GetOpaqueClangQualType () 50{ 51 Type *var_type = m_variable_sp->GetType(); 52 if (var_type) 53 return var_type->GetOpaqueClangQualType(); 54 return NULL; 55} 56 57ConstString 58ValueObjectVariable::GetTypeName() 59{ 60 Type * var_type = m_variable_sp->GetType(); 61 if (var_type) 62 return var_type->GetName(); 63 ConstString empty_type_name; 64 return empty_type_name; 65} 66 67uint32_t 68ValueObjectVariable::CalculateNumChildren() 69{ 70 Type *var_type = m_variable_sp->GetType(); 71 if (var_type) 72 return var_type->GetNumChildren(true); 73 return 0; 74} 75 76clang::ASTContext * 77ValueObjectVariable::GetClangAST () 78{ 79 return m_variable_sp->GetType()->GetClangAST(); 80} 81 82size_t 83ValueObjectVariable::GetByteSize() 84{ 85 return m_variable_sp->GetType()->GetByteSize(); 86} 87 88lldb::ValueType 89ValueObjectVariable::GetValueType() const 90{ 91 if (m_variable_sp) 92 return m_variable_sp->GetScope(); 93 return lldb::eValueTypeInvalid; 94} 95 96 97 98void 99ValueObjectVariable::UpdateValue (ExecutionContextScope *exe_scope) 100{ 101 SetValueIsValid (false); 102 m_error.Clear(); 103 104 Variable *variable = m_variable_sp.get(); 105 DWARFExpression &expr = variable->LocationExpression(); 106 Value old_value(m_value); 107 ExecutionContext exe_ctx (exe_scope); 108 if (expr.Evaluate (&exe_ctx, GetClangAST(), NULL, m_value, &m_error)) 109 { 110 m_value.SetContext(Value::eContextTypeDCVariable, variable); 111 112 Value::ValueType value_type = m_value.GetValueType(); 113 114 switch (value_type) 115 { 116 default: 117 assert(!"Unhandled expression result value kind..."); 118 break; 119 120 case Value::eValueTypeScalar: 121 // The variable value is in the Scalar value inside the m_value. 122 // We can point our m_data right to it. 123 m_error = m_value.GetValueAsData (&exe_ctx, GetClangAST(), m_data, 0); 124 break; 125 126 case Value::eValueTypeFileAddress: 127 case Value::eValueTypeLoadAddress: 128 case Value::eValueTypeHostAddress: 129 // The DWARF expression result was an address in the inferior 130 // process. If this variable is an aggregate type, we just need 131 // the address as the main value as all child variable objects 132 // will rely upon this location and add an offset and then read 133 // their own values as needed. If this variable is a simple 134 // type, we read all data for it into m_data. 135 // Make sure this type has a value before we try and read it 136 137 // If we have a file address, convert it to a load address if we can. 138 if (value_type == Value::eValueTypeFileAddress && exe_ctx.process) 139 { 140 lldb::addr_t file_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 141 if (file_addr != LLDB_INVALID_ADDRESS) 142 { 143 SymbolContext var_sc; 144 variable->CalculateSymbolContext(&var_sc); 145 if (var_sc.module_sp) 146 { 147 ObjectFile *objfile = var_sc.module_sp->GetObjectFile(); 148 if (objfile) 149 { 150 Address so_addr(file_addr, objfile->GetSectionList()); 151 lldb::addr_t load_addr = so_addr.GetLoadAddress (exe_ctx.process); 152 if (load_addr != LLDB_INVALID_ADDRESS) 153 { 154 m_value.SetValueType(Value::eValueTypeLoadAddress); 155 m_value.GetScalar() = load_addr; 156 } 157 } 158 } 159 } 160 } 161 162 if (ClangASTContext::IsAggregateType (GetOpaqueClangQualType())) 163 { 164 // this value object represents an aggregate type whose 165 // children have values, but this object does not. So we 166 // say we are changed if our location has changed. 167 SetValueDidChange (value_type != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar()); 168 } 169 else 170 { 171 // Copy the Value and set the context to use our Variable 172 // so it can extract read its value into m_data appropriately 173 Value value(m_value); 174 value.SetContext(Value::eContextTypeDCVariable, variable); 175 m_error = value.GetValueAsData(&exe_ctx, GetClangAST(), m_data, 0); 176 } 177 break; 178 } 179 180 SetValueIsValid (m_error.Success()); 181 } 182} 183 184 185 186bool 187ValueObjectVariable::IsInScope (StackFrame *frame) 188{ 189 return m_variable_sp->IsInScope (frame); 190} 191 192