ValueObjectVariable.cpp revision 178710cd4307f3d44dc76ebd70fc7daf7ebe17c5
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 lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS; 107 ExecutionContext exe_ctx (exe_scope); 108 if (expr.IsLocationList()) 109 { 110 SymbolContext sc; 111 variable->CalculateSymbolContext (&sc); 112 if (sc.function) 113 loclist_base_load_addr = sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (exe_ctx.process); 114 } 115 Value old_value(m_value); 116 if (expr.Evaluate (&exe_ctx, GetClangAST(), loclist_base_load_addr, NULL, m_value, &m_error)) 117 { 118 m_value.SetContext(Value::eContextTypeDCVariable, variable); 119 120 Value::ValueType value_type = m_value.GetValueType(); 121 122 switch (value_type) 123 { 124 default: 125 assert(!"Unhandled expression result value kind..."); 126 break; 127 128 case Value::eValueTypeScalar: 129 // The variable value is in the Scalar value inside the m_value. 130 // We can point our m_data right to it. 131 m_error = m_value.GetValueAsData (&exe_ctx, GetClangAST(), m_data, 0); 132 break; 133 134 case Value::eValueTypeFileAddress: 135 case Value::eValueTypeLoadAddress: 136 case Value::eValueTypeHostAddress: 137 // The DWARF expression result was an address in the inferior 138 // process. If this variable is an aggregate type, we just need 139 // the address as the main value as all child variable objects 140 // will rely upon this location and add an offset and then read 141 // their own values as needed. If this variable is a simple 142 // type, we read all data for it into m_data. 143 // Make sure this type has a value before we try and read it 144 145 // If we have a file address, convert it to a load address if we can. 146 if (value_type == Value::eValueTypeFileAddress && exe_ctx.process) 147 { 148 lldb::addr_t file_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); 149 if (file_addr != LLDB_INVALID_ADDRESS) 150 { 151 SymbolContext var_sc; 152 variable->CalculateSymbolContext(&var_sc); 153 if (var_sc.module_sp) 154 { 155 ObjectFile *objfile = var_sc.module_sp->GetObjectFile(); 156 if (objfile) 157 { 158 Address so_addr(file_addr, objfile->GetSectionList()); 159 lldb::addr_t load_addr = so_addr.GetLoadAddress (exe_ctx.process); 160 if (load_addr != LLDB_INVALID_ADDRESS) 161 { 162 m_value.SetValueType(Value::eValueTypeLoadAddress); 163 m_value.GetScalar() = load_addr; 164 } 165 } 166 } 167 } 168 } 169 170 if (ClangASTContext::IsAggregateType (GetOpaqueClangQualType())) 171 { 172 // this value object represents an aggregate type whose 173 // children have values, but this object does not. So we 174 // say we are changed if our location has changed. 175 SetValueDidChange (value_type != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar()); 176 } 177 else 178 { 179 // Copy the Value and set the context to use our Variable 180 // so it can extract read its value into m_data appropriately 181 Value value(m_value); 182 value.SetContext(Value::eContextTypeDCVariable, variable); 183 m_error = value.GetValueAsData(&exe_ctx, GetClangAST(), m_data, 0); 184 } 185 break; 186 } 187 188 SetValueIsValid (m_error.Success()); 189 } 190} 191 192 193 194bool 195ValueObjectVariable::IsInScope (StackFrame *frame) 196{ 197 return m_variable_sp->IsInScope (frame); 198} 199 200