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