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