xref: /freebsd/contrib/llvm-project/lldb/source/Core/ValueObjectVariable.cpp (revision 0fca6ea1d4eea4c934cfff25ac9ee8ad6fe95583)
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
Create(ExecutionContextScope * exe_scope,const lldb::VariableSP & var_sp)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 
ValueObjectVariable(ExecutionContextScope * exe_scope,ValueObjectManager & manager,const lldb::VariableSP & var_sp)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 
GetCompilerTypeImpl()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 
GetTypeName()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 
GetDisplayTypeName()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 
GetQualifiedTypeName()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>
CalculateNumChildren(uint32_t max)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 
GetByteSize()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 
GetValueType() const124 lldb::ValueType ValueObjectVariable::GetValueType() const {
125   if (m_variable_sp)
126     return m_variable_sp->GetScope();
127   return lldb::eValueTypeInvalid;
128 }
129 
UpdateValue()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 
DoUpdateChildrenAddressType(ValueObject & valobj)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 
IsInScope()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 
GetModule()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 
GetSymbolContextScope()344 SymbolContextScope *ValueObjectVariable::GetSymbolContextScope() {
345   if (m_variable_sp)
346     return m_variable_sp->GetSymbolContextScope();
347   return nullptr;
348 }
349 
GetDeclaration(Declaration & decl)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 
GetLocationAsCString()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 
SetValueFromCString(const char * value_str,Status & error)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 
SetData(DataExtractor & data,Status & error)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