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