1 //===-- ValueObjectMemory.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/ValueObjectMemory.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 #include "lldb/Core/ValueObject.h" 21 22 #include "lldb/Symbol/ObjectFile.h" 23 #include "lldb/Symbol/SymbolContext.h" 24 #include "lldb/Symbol/Type.h" 25 #include "lldb/Symbol/Variable.h" 26 27 #include "lldb/Target/ExecutionContext.h" 28 #include "lldb/Target/Process.h" 29 #include "lldb/Target/RegisterContext.h" 30 #include "lldb/Target/Target.h" 31 #include "lldb/Target/Thread.h" 32 33 using namespace lldb; 34 using namespace lldb_private; 35 36 ValueObjectSP 37 ValueObjectMemory::Create (ExecutionContextScope *exe_scope, 38 const char *name, 39 const Address &address, 40 lldb::TypeSP &type_sp) 41 { 42 return (new ValueObjectMemory (exe_scope, name, address, type_sp))->GetSP(); 43 } 44 45 ValueObjectSP 46 ValueObjectMemory::Create (ExecutionContextScope *exe_scope, 47 const char *name, 48 const Address &address, 49 const ClangASTType &ast_type) 50 { 51 return (new ValueObjectMemory (exe_scope, name, address, ast_type))->GetSP(); 52 } 53 54 ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope, 55 const char *name, 56 const Address &address, 57 lldb::TypeSP &type_sp) : 58 ValueObject(exe_scope), 59 m_address (address), 60 m_type_sp(type_sp), 61 m_clang_type() 62 { 63 // Do not attempt to construct one of these objects with no variable! 64 assert (m_type_sp.get() != NULL); 65 SetName (ConstString(name)); 66 m_value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get()); 67 TargetSP target_sp (GetTargetSP()); 68 lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get()); 69 if (load_address != LLDB_INVALID_ADDRESS) 70 { 71 m_value.SetValueType(Value::eValueTypeLoadAddress); 72 m_value.GetScalar() = load_address; 73 } 74 else 75 { 76 lldb::addr_t file_address = m_address.GetFileAddress(); 77 if (file_address != LLDB_INVALID_ADDRESS) 78 { 79 m_value.SetValueType(Value::eValueTypeFileAddress); 80 m_value.GetScalar() = file_address; 81 } 82 else 83 { 84 m_value.GetScalar() = m_address.GetOffset(); 85 m_value.SetValueType (Value::eValueTypeScalar); 86 } 87 } 88 } 89 90 ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope, 91 const char *name, 92 const Address &address, 93 const ClangASTType &ast_type) : 94 ValueObject(exe_scope), 95 m_address (address), 96 m_type_sp(), 97 m_clang_type(ast_type) 98 { 99 // Do not attempt to construct one of these objects with no variable! 100 assert (m_clang_type.GetASTContext()); 101 assert (m_clang_type.GetOpaqueQualType()); 102 103 TargetSP target_sp (GetTargetSP()); 104 105 SetName (ConstString(name)); 106 // m_value.SetContext(Value::eContextTypeClangType, m_clang_type.GetOpaqueQualType()); 107 m_value.SetClangType(m_clang_type); 108 lldb::addr_t load_address = m_address.GetLoadAddress (target_sp.get()); 109 if (load_address != LLDB_INVALID_ADDRESS) 110 { 111 m_value.SetValueType(Value::eValueTypeLoadAddress); 112 m_value.GetScalar() = load_address; 113 } 114 else 115 { 116 lldb::addr_t file_address = m_address.GetFileAddress(); 117 if (file_address != LLDB_INVALID_ADDRESS) 118 { 119 m_value.SetValueType(Value::eValueTypeFileAddress); 120 m_value.GetScalar() = file_address; 121 } 122 else 123 { 124 m_value.GetScalar() = m_address.GetOffset(); 125 m_value.SetValueType (Value::eValueTypeScalar); 126 } 127 } 128 } 129 130 ValueObjectMemory::~ValueObjectMemory() 131 { 132 } 133 134 ClangASTType 135 ValueObjectMemory::GetClangTypeImpl () 136 { 137 if (m_type_sp) 138 return m_type_sp->GetClangForwardType(); 139 return m_clang_type; 140 } 141 142 ConstString 143 ValueObjectMemory::GetTypeName() 144 { 145 if (m_type_sp) 146 return m_type_sp->GetName(); 147 return m_clang_type.GetConstTypeName(); 148 } 149 150 ConstString 151 ValueObjectMemory::GetDisplayTypeName() 152 { 153 if (m_type_sp) 154 return m_type_sp->GetClangForwardType().GetDisplayTypeName(); 155 return m_clang_type.GetDisplayTypeName(); 156 } 157 158 size_t 159 ValueObjectMemory::CalculateNumChildren() 160 { 161 if (m_type_sp) 162 return m_type_sp->GetNumChildren(true); 163 const bool omit_empty_base_classes = true; 164 return m_clang_type.GetNumChildren (omit_empty_base_classes); 165 } 166 167 uint64_t 168 ValueObjectMemory::GetByteSize() 169 { 170 if (m_type_sp) 171 return m_type_sp->GetByteSize(); 172 return m_clang_type.GetByteSize (nullptr); 173 } 174 175 lldb::ValueType 176 ValueObjectMemory::GetValueType() const 177 { 178 // RETHINK: Should this be inherited from somewhere? 179 return lldb::eValueTypeVariableGlobal; 180 } 181 182 bool 183 ValueObjectMemory::UpdateValue () 184 { 185 SetValueIsValid (false); 186 m_error.Clear(); 187 188 ExecutionContext exe_ctx (GetExecutionContextRef()); 189 190 Target *target = exe_ctx.GetTargetPtr(); 191 if (target) 192 { 193 m_data.SetByteOrder(target->GetArchitecture().GetByteOrder()); 194 m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize()); 195 } 196 197 Value old_value(m_value); 198 if (m_address.IsValid()) 199 { 200 Value::ValueType value_type = m_value.GetValueType(); 201 202 switch (value_type) 203 { 204 default: 205 assert(!"Unhandled expression result value kind..."); 206 break; 207 208 case Value::eValueTypeScalar: 209 // The variable value is in the Scalar value inside the m_value. 210 // We can point our m_data right to it. 211 m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get()); 212 break; 213 214 case Value::eValueTypeFileAddress: 215 case Value::eValueTypeLoadAddress: 216 case Value::eValueTypeHostAddress: 217 // The DWARF expression result was an address in the inferior 218 // process. If this variable is an aggregate type, we just need 219 // the address as the main value as all child variable objects 220 // will rely upon this location and add an offset and then read 221 // their own values as needed. If this variable is a simple 222 // type, we read all data for it into m_data. 223 // Make sure this type has a value before we try and read it 224 225 // If we have a file address, convert it to a load address if we can. 226 if (value_type == Value::eValueTypeFileAddress && exe_ctx.GetProcessPtr()) 227 { 228 lldb::addr_t load_addr = m_address.GetLoadAddress(target); 229 if (load_addr != LLDB_INVALID_ADDRESS) 230 { 231 m_value.SetValueType(Value::eValueTypeLoadAddress); 232 m_value.GetScalar() = load_addr; 233 } 234 } 235 236 if (!CanProvideValue()) 237 { 238 // this value object represents an aggregate type whose 239 // children have values, but this object does not. So we 240 // say we are changed if our location has changed. 241 SetValueDidChange (value_type != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar()); 242 } 243 else 244 { 245 // Copy the Value and set the context to use our Variable 246 // so it can extract read its value into m_data appropriately 247 Value value(m_value); 248 if (m_type_sp) 249 value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get()); 250 else 251 { 252 //value.SetContext(Value::eContextTypeClangType, m_clang_type.GetOpaqueQualType()); 253 value.SetClangType(m_clang_type); 254 } 255 256 m_error = value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get()); 257 } 258 break; 259 } 260 261 SetValueIsValid (m_error.Success()); 262 } 263 return m_error.Success(); 264 } 265 266 267 268 bool 269 ValueObjectMemory::IsInScope () 270 { 271 // FIXME: Maybe try to read the memory address, and if that works, then 272 // we are in scope? 273 return true; 274 } 275 276 277 lldb::ModuleSP 278 ValueObjectMemory::GetModule() 279 { 280 return m_address.GetModule(); 281 } 282 283 284