1 //===-- ValueObjectVariable.cpp -------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/Core/ValueObjectVariable.h" 10 11 #include "lldb/Core/Address.h" 12 #include "lldb/Core/AddressRange.h" 13 #include "lldb/Core/Declaration.h" 14 #include "lldb/Core/Module.h" 15 #include "lldb/Core/Value.h" 16 #include "lldb/Expression/DWARFExpressionList.h" 17 #include "lldb/Symbol/Function.h" 18 #include "lldb/Symbol/ObjectFile.h" 19 #include "lldb/Symbol/SymbolContext.h" 20 #include "lldb/Symbol/SymbolContextScope.h" 21 #include "lldb/Symbol/Type.h" 22 #include "lldb/Symbol/Variable.h" 23 #include "lldb/Target/ExecutionContext.h" 24 #include "lldb/Target/Process.h" 25 #include "lldb/Target/RegisterContext.h" 26 #include "lldb/Target/Target.h" 27 #include "lldb/Utility/DataExtractor.h" 28 #include "lldb/Utility/RegisterValue.h" 29 #include "lldb/Utility/Scalar.h" 30 #include "lldb/Utility/Status.h" 31 #include "lldb/lldb-private-enumerations.h" 32 #include "lldb/lldb-types.h" 33 34 #include "llvm/ADT/StringRef.h" 35 36 #include <cassert> 37 #include <memory> 38 39 namespace lldb_private { 40 class ExecutionContextScope; 41 } 42 namespace lldb_private { 43 class StackFrame; 44 } 45 namespace lldb_private { 46 struct RegisterInfo; 47 } 48 using namespace lldb_private; 49 50 lldb::ValueObjectSP 51 ValueObjectVariable::Create(ExecutionContextScope *exe_scope, 52 const lldb::VariableSP &var_sp) { 53 auto manager_sp = ValueObjectManager::Create(); 54 return (new ValueObjectVariable(exe_scope, *manager_sp, var_sp))->GetSP(); 55 } 56 57 ValueObjectVariable::ValueObjectVariable(ExecutionContextScope *exe_scope, 58 ValueObjectManager &manager, 59 const lldb::VariableSP &var_sp) 60 : ValueObject(exe_scope, manager), m_variable_sp(var_sp) { 61 // Do not attempt to construct one of these objects with no variable! 62 assert(m_variable_sp.get() != nullptr); 63 m_name = var_sp->GetName(); 64 } 65 66 ValueObjectVariable::~ValueObjectVariable() = default; 67 68 CompilerType ValueObjectVariable::GetCompilerTypeImpl() { 69 Type *var_type = m_variable_sp->GetType(); 70 if (var_type) 71 return var_type->GetForwardCompilerType(); 72 return CompilerType(); 73 } 74 75 ConstString ValueObjectVariable::GetTypeName() { 76 Type *var_type = m_variable_sp->GetType(); 77 if (var_type) 78 return var_type->GetName(); 79 return ConstString(); 80 } 81 82 ConstString ValueObjectVariable::GetDisplayTypeName() { 83 Type *var_type = m_variable_sp->GetType(); 84 if (var_type) 85 return var_type->GetForwardCompilerType().GetDisplayTypeName(); 86 return ConstString(); 87 } 88 89 ConstString ValueObjectVariable::GetQualifiedTypeName() { 90 Type *var_type = m_variable_sp->GetType(); 91 if (var_type) 92 return var_type->GetQualifiedName(); 93 return ConstString(); 94 } 95 96 size_t ValueObjectVariable::CalculateNumChildren(uint32_t max) { 97 CompilerType type(GetCompilerType()); 98 99 if (!type.IsValid()) 100 return 0; 101 102 ExecutionContext exe_ctx(GetExecutionContextRef()); 103 const bool omit_empty_base_classes = true; 104 auto child_count = type.GetNumChildren(omit_empty_base_classes, &exe_ctx); 105 return child_count <= max ? child_count : max; 106 } 107 108 llvm::Optional<uint64_t> ValueObjectVariable::GetByteSize() { 109 ExecutionContext exe_ctx(GetExecutionContextRef()); 110 111 CompilerType type(GetCompilerType()); 112 113 if (!type.IsValid()) 114 return {}; 115 116 return type.GetByteSize(exe_ctx.GetBestExecutionContextScope()); 117 } 118 119 lldb::ValueType ValueObjectVariable::GetValueType() const { 120 if (m_variable_sp) 121 return m_variable_sp->GetScope(); 122 return lldb::eValueTypeInvalid; 123 } 124 125 bool ValueObjectVariable::UpdateValue() { 126 SetValueIsValid(false); 127 m_error.Clear(); 128 129 Variable *variable = m_variable_sp.get(); 130 DWARFExpressionList &expr_list = variable->LocationExpressionList(); 131 132 if (variable->GetLocationIsConstantValueData()) { 133 // expr doesn't contain DWARF bytes, it contains the constant variable 134 // value bytes themselves... 135 if (expr_list.GetExpressionData(m_data)) { 136 if (m_data.GetDataStart() && m_data.GetByteSize()) 137 m_value.SetBytes(m_data.GetDataStart(), m_data.GetByteSize()); 138 m_value.SetContext(Value::ContextType::Variable, variable); 139 } else 140 m_error.SetErrorString("empty constant data"); 141 // constant bytes can't be edited - sorry 142 m_resolved_value.SetContext(Value::ContextType::Invalid, nullptr); 143 } else { 144 lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS; 145 ExecutionContext exe_ctx(GetExecutionContextRef()); 146 147 Target *target = exe_ctx.GetTargetPtr(); 148 if (target) { 149 m_data.SetByteOrder(target->GetArchitecture().GetByteOrder()); 150 m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize()); 151 } 152 153 if (!expr_list.IsAlwaysValidSingleExpr()) { 154 SymbolContext sc; 155 variable->CalculateSymbolContext(&sc); 156 if (sc.function) 157 loclist_base_load_addr = 158 sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress( 159 target); 160 } 161 Value old_value(m_value); 162 if (expr_list.Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, nullptr, 163 nullptr, m_value, &m_error)) { 164 m_resolved_value = m_value; 165 m_value.SetContext(Value::ContextType::Variable, variable); 166 167 CompilerType compiler_type = GetCompilerType(); 168 if (compiler_type.IsValid()) 169 m_value.SetCompilerType(compiler_type); 170 171 Value::ValueType value_type = m_value.GetValueType(); 172 173 // The size of the buffer within m_value can be less than the size 174 // prescribed by its type. E.g. this can happen when an expression only 175 // partially describes an object (say, because it contains DW_OP_piece). 176 // 177 // In this case, grow m_value to the expected size. An alternative way to 178 // handle this is to teach Value::GetValueAsData() and ValueObjectChild 179 // not to read past the end of a host buffer, but this gets impractically 180 // complicated as a Value's host buffer may be shared with a distant 181 // ancestor or sibling in the ValueObject hierarchy. 182 // 183 // FIXME: When we grow m_value, we should represent the added bits as 184 // undefined somehow instead of as 0's. 185 if (value_type == Value::ValueType::HostAddress && 186 compiler_type.IsValid()) { 187 if (size_t value_buf_size = m_value.GetBuffer().GetByteSize()) { 188 size_t value_size = m_value.GetValueByteSize(&m_error, &exe_ctx); 189 if (m_error.Success() && value_buf_size < value_size) 190 m_value.ResizeData(value_size); 191 } 192 } 193 194 Process *process = exe_ctx.GetProcessPtr(); 195 const bool process_is_alive = process && process->IsAlive(); 196 197 switch (value_type) { 198 case Value::ValueType::Invalid: 199 m_error.SetErrorString("invalid value"); 200 break; 201 case Value::ValueType::Scalar: 202 // The variable value is in the Scalar value inside the m_value. We can 203 // point our m_data right to it. 204 m_error = 205 m_value.GetValueAsData(&exe_ctx, m_data, GetModule().get()); 206 break; 207 208 case Value::ValueType::FileAddress: 209 case Value::ValueType::LoadAddress: 210 case Value::ValueType::HostAddress: 211 // The DWARF expression result was an address in the inferior process. 212 // If this variable is an aggregate type, we just need the address as 213 // the main value as all child variable objects will rely upon this 214 // location and add an offset and then read their own values as needed. 215 // If this variable is a simple type, we read all data for it into 216 // m_data. Make sure this type has a value before we try and read it 217 218 // If we have a file address, convert it to a load address if we can. 219 if (value_type == Value::ValueType::FileAddress && process_is_alive) 220 m_value.ConvertToLoadAddress(GetModule().get(), target); 221 222 if (!CanProvideValue()) { 223 // this value object represents an aggregate type whose children have 224 // values, but this object does not. So we say we are changed if our 225 // location has changed. 226 SetValueDidChange(value_type != old_value.GetValueType() || 227 m_value.GetScalar() != old_value.GetScalar()); 228 } else { 229 // Copy the Value and set the context to use our Variable so it can 230 // extract read its value into m_data appropriately 231 Value value(m_value); 232 value.SetContext(Value::ContextType::Variable, variable); 233 m_error = 234 value.GetValueAsData(&exe_ctx, m_data, GetModule().get()); 235 236 SetValueDidChange(value_type != old_value.GetValueType() || 237 m_value.GetScalar() != old_value.GetScalar()); 238 } 239 break; 240 } 241 242 SetValueIsValid(m_error.Success()); 243 } else { 244 // could not find location, won't allow editing 245 m_resolved_value.SetContext(Value::ContextType::Invalid, nullptr); 246 } 247 } 248 249 return m_error.Success(); 250 } 251 252 void ValueObjectVariable::DoUpdateChildrenAddressType(ValueObject &valobj) { 253 Value::ValueType value_type = valobj.GetValue().GetValueType(); 254 ExecutionContext exe_ctx(GetExecutionContextRef()); 255 Process *process = exe_ctx.GetProcessPtr(); 256 const bool process_is_alive = process && process->IsAlive(); 257 const uint32_t type_info = valobj.GetCompilerType().GetTypeInfo(); 258 const bool is_pointer_or_ref = 259 (type_info & (lldb::eTypeIsPointer | lldb::eTypeIsReference)) != 0; 260 261 switch (value_type) { 262 case Value::ValueType::Invalid: 263 break; 264 case Value::ValueType::FileAddress: 265 // If this type is a pointer, then its children will be considered load 266 // addresses if the pointer or reference is dereferenced, but only if 267 // the process is alive. 268 // 269 // There could be global variables like in the following code: 270 // struct LinkedListNode { Foo* foo; LinkedListNode* next; }; 271 // Foo g_foo1; 272 // Foo g_foo2; 273 // LinkedListNode g_second_node = { &g_foo2, NULL }; 274 // LinkedListNode g_first_node = { &g_foo1, &g_second_node }; 275 // 276 // When we aren't running, we should be able to look at these variables 277 // using the "target variable" command. Children of the "g_first_node" 278 // always will be of the same address type as the parent. But children 279 // of the "next" member of LinkedListNode will become load addresses if 280 // we have a live process, or remain a file address if it was a file 281 // address. 282 if (process_is_alive && is_pointer_or_ref) 283 valobj.SetAddressTypeOfChildren(eAddressTypeLoad); 284 else 285 valobj.SetAddressTypeOfChildren(eAddressTypeFile); 286 break; 287 case Value::ValueType::HostAddress: 288 // Same as above for load addresses, except children of pointer or refs 289 // are always load addresses. Host addresses are used to store freeze 290 // dried variables. If this type is a struct, the entire struct 291 // contents will be copied into the heap of the 292 // LLDB process, but we do not currently follow any pointers. 293 if (is_pointer_or_ref) 294 valobj.SetAddressTypeOfChildren(eAddressTypeLoad); 295 else 296 valobj.SetAddressTypeOfChildren(eAddressTypeHost); 297 break; 298 case Value::ValueType::LoadAddress: 299 case Value::ValueType::Scalar: 300 valobj.SetAddressTypeOfChildren(eAddressTypeLoad); 301 break; 302 } 303 } 304 305 306 307 bool ValueObjectVariable::IsInScope() { 308 const ExecutionContextRef &exe_ctx_ref = GetExecutionContextRef(); 309 if (exe_ctx_ref.HasFrameRef()) { 310 ExecutionContext exe_ctx(exe_ctx_ref); 311 StackFrame *frame = exe_ctx.GetFramePtr(); 312 if (frame) { 313 return m_variable_sp->IsInScope(frame); 314 } else { 315 // This ValueObject had a frame at one time, but now we can't locate it, 316 // so return false since we probably aren't in scope. 317 return false; 318 } 319 } 320 // We have a variable that wasn't tied to a frame, which means it is a global 321 // and is always in scope. 322 return true; 323 } 324 325 lldb::ModuleSP ValueObjectVariable::GetModule() { 326 if (m_variable_sp) { 327 SymbolContextScope *sc_scope = m_variable_sp->GetSymbolContextScope(); 328 if (sc_scope) { 329 return sc_scope->CalculateSymbolContextModule(); 330 } 331 } 332 return lldb::ModuleSP(); 333 } 334 335 SymbolContextScope *ValueObjectVariable::GetSymbolContextScope() { 336 if (m_variable_sp) 337 return m_variable_sp->GetSymbolContextScope(); 338 return nullptr; 339 } 340 341 bool ValueObjectVariable::GetDeclaration(Declaration &decl) { 342 if (m_variable_sp) { 343 decl = m_variable_sp->GetDeclaration(); 344 return true; 345 } 346 return false; 347 } 348 349 const char *ValueObjectVariable::GetLocationAsCString() { 350 if (m_resolved_value.GetContextType() == Value::ContextType::RegisterInfo) 351 return GetLocationAsCStringImpl(m_resolved_value, m_data); 352 else 353 return ValueObject::GetLocationAsCString(); 354 } 355 356 bool ValueObjectVariable::SetValueFromCString(const char *value_str, 357 Status &error) { 358 if (!UpdateValueIfNeeded()) { 359 error.SetErrorString("unable to update value before writing"); 360 return false; 361 } 362 363 if (m_resolved_value.GetContextType() == Value::ContextType::RegisterInfo) { 364 RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo(); 365 ExecutionContext exe_ctx(GetExecutionContextRef()); 366 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext(); 367 RegisterValue reg_value; 368 if (!reg_info || !reg_ctx) { 369 error.SetErrorString("unable to retrieve register info"); 370 return false; 371 } 372 error = reg_value.SetValueFromString(reg_info, llvm::StringRef(value_str)); 373 if (error.Fail()) 374 return false; 375 if (reg_ctx->WriteRegister(reg_info, reg_value)) { 376 SetNeedsUpdate(); 377 return true; 378 } else { 379 error.SetErrorString("unable to write back to register"); 380 return false; 381 } 382 } else 383 return ValueObject::SetValueFromCString(value_str, error); 384 } 385 386 bool ValueObjectVariable::SetData(DataExtractor &data, Status &error) { 387 if (!UpdateValueIfNeeded()) { 388 error.SetErrorString("unable to update value before writing"); 389 return false; 390 } 391 392 if (m_resolved_value.GetContextType() == Value::ContextType::RegisterInfo) { 393 RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo(); 394 ExecutionContext exe_ctx(GetExecutionContextRef()); 395 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext(); 396 RegisterValue reg_value; 397 if (!reg_info || !reg_ctx) { 398 error.SetErrorString("unable to retrieve register info"); 399 return false; 400 } 401 error = reg_value.SetValueFromData(reg_info, data, 0, true); 402 if (error.Fail()) 403 return false; 404 if (reg_ctx->WriteRegister(reg_info, reg_value)) { 405 SetNeedsUpdate(); 406 return true; 407 } else { 408 error.SetErrorString("unable to write back to register"); 409 return false; 410 } 411 } else 412 return ValueObject::SetData(data, error); 413 } 414