1 //===-- ValueObjectVariable.cpp ---------------------------------*- C++ -*-===//
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/Module.h"
14 #include "lldb/Core/Value.h"
15 #include "lldb/Expression/DWARFExpression.h"
16 #include "lldb/Symbol/Declaration.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 <assert.h>
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
Create(ExecutionContextScope * exe_scope,const lldb::VariableSP & var_sp)51 ValueObjectVariable::Create(ExecutionContextScope *exe_scope,
52 const lldb::VariableSP &var_sp) {
53 return (new ValueObjectVariable(exe_scope, var_sp))->GetSP();
54 }
55
ValueObjectVariable(ExecutionContextScope * exe_scope,const lldb::VariableSP & var_sp)56 ValueObjectVariable::ValueObjectVariable(ExecutionContextScope *exe_scope,
57 const lldb::VariableSP &var_sp)
58 : ValueObject(exe_scope), m_variable_sp(var_sp) {
59 // Do not attempt to construct one of these objects with no variable!
60 assert(m_variable_sp.get() != nullptr);
61 m_name = var_sp->GetName();
62 }
63
~ValueObjectVariable()64 ValueObjectVariable::~ValueObjectVariable() {}
65
GetCompilerTypeImpl()66 CompilerType ValueObjectVariable::GetCompilerTypeImpl() {
67 Type *var_type = m_variable_sp->GetType();
68 if (var_type)
69 return var_type->GetForwardCompilerType();
70 return CompilerType();
71 }
72
GetTypeName()73 ConstString ValueObjectVariable::GetTypeName() {
74 Type *var_type = m_variable_sp->GetType();
75 if (var_type)
76 return var_type->GetName();
77 return ConstString();
78 }
79
GetDisplayTypeName()80 ConstString ValueObjectVariable::GetDisplayTypeName() {
81 Type *var_type = m_variable_sp->GetType();
82 if (var_type)
83 return var_type->GetForwardCompilerType().GetDisplayTypeName();
84 return ConstString();
85 }
86
GetQualifiedTypeName()87 ConstString ValueObjectVariable::GetQualifiedTypeName() {
88 Type *var_type = m_variable_sp->GetType();
89 if (var_type)
90 return var_type->GetQualifiedName();
91 return ConstString();
92 }
93
CalculateNumChildren(uint32_t max)94 size_t ValueObjectVariable::CalculateNumChildren(uint32_t max) {
95 CompilerType type(GetCompilerType());
96
97 if (!type.IsValid())
98 return 0;
99
100 ExecutionContext exe_ctx(GetExecutionContextRef());
101 const bool omit_empty_base_classes = true;
102 auto child_count = type.GetNumChildren(omit_empty_base_classes, &exe_ctx);
103 return child_count <= max ? child_count : max;
104 }
105
GetByteSize()106 uint64_t ValueObjectVariable::GetByteSize() {
107 ExecutionContext exe_ctx(GetExecutionContextRef());
108
109 CompilerType type(GetCompilerType());
110
111 if (!type.IsValid())
112 return 0;
113
114 return type.GetByteSize(exe_ctx.GetBestExecutionContextScope()).getValueOr(0);
115 }
116
GetValueType() const117 lldb::ValueType ValueObjectVariable::GetValueType() const {
118 if (m_variable_sp)
119 return m_variable_sp->GetScope();
120 return lldb::eValueTypeInvalid;
121 }
122
UpdateValue()123 bool ValueObjectVariable::UpdateValue() {
124 SetValueIsValid(false);
125 m_error.Clear();
126
127 Variable *variable = m_variable_sp.get();
128 DWARFExpression &expr = variable->LocationExpression();
129
130 if (variable->GetLocationIsConstantValueData()) {
131 // expr doesn't contain DWARF bytes, it contains the constant variable
132 // value bytes themselves...
133 if (expr.GetExpressionData(m_data))
134 m_value.SetContext(Value::eContextTypeVariable, variable);
135 else
136 m_error.SetErrorString("empty constant data");
137 // constant bytes can't be edited - sorry
138 m_resolved_value.SetContext(Value::eContextTypeInvalid, nullptr);
139 } else {
140 lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS;
141 ExecutionContext exe_ctx(GetExecutionContextRef());
142
143 Target *target = exe_ctx.GetTargetPtr();
144 if (target) {
145 m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());
146 m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
147 }
148
149 if (expr.IsLocationList()) {
150 SymbolContext sc;
151 variable->CalculateSymbolContext(&sc);
152 if (sc.function)
153 loclist_base_load_addr =
154 sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(
155 target);
156 }
157 Value old_value(m_value);
158 if (expr.Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, nullptr,
159 nullptr, m_value, &m_error)) {
160 m_resolved_value = m_value;
161 m_value.SetContext(Value::eContextTypeVariable, variable);
162
163 CompilerType compiler_type = GetCompilerType();
164 if (compiler_type.IsValid())
165 m_value.SetCompilerType(compiler_type);
166
167 Value::ValueType value_type = m_value.GetValueType();
168
169 Process *process = exe_ctx.GetProcessPtr();
170 const bool process_is_alive = process && process->IsAlive();
171
172 switch (value_type) {
173 case Value::eValueTypeVector:
174 // fall through
175 case Value::eValueTypeScalar:
176 // The variable value is in the Scalar value inside the m_value. We can
177 // point our m_data right to it.
178 m_error =
179 m_value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
180 break;
181
182 case Value::eValueTypeFileAddress:
183 case Value::eValueTypeLoadAddress:
184 case Value::eValueTypeHostAddress:
185 // The DWARF expression result was an address in the inferior process.
186 // If this variable is an aggregate type, we just need the address as
187 // the main value as all child variable objects will rely upon this
188 // location and add an offset and then read their own values as needed.
189 // If this variable is a simple type, we read all data for it into
190 // m_data. Make sure this type has a value before we try and read it
191
192 // If we have a file address, convert it to a load address if we can.
193 if (value_type == Value::eValueTypeFileAddress && process_is_alive)
194 m_value.ConvertToLoadAddress(GetModule().get(), target);
195
196 if (!CanProvideValue()) {
197 // this value object represents an aggregate type whose children have
198 // values, but this object does not. So we say we are changed if our
199 // location has changed.
200 SetValueDidChange(value_type != old_value.GetValueType() ||
201 m_value.GetScalar() != old_value.GetScalar());
202 } else {
203 // Copy the Value and set the context to use our Variable so it can
204 // extract read its value into m_data appropriately
205 Value value(m_value);
206 value.SetContext(Value::eContextTypeVariable, variable);
207 m_error =
208 value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
209
210 SetValueDidChange(value_type != old_value.GetValueType() ||
211 m_value.GetScalar() != old_value.GetScalar());
212 }
213 break;
214 }
215
216 SetValueIsValid(m_error.Success());
217 } else {
218 // could not find location, won't allow editing
219 m_resolved_value.SetContext(Value::eContextTypeInvalid, nullptr);
220 }
221 }
222 return m_error.Success();
223 }
224
IsInScope()225 bool ValueObjectVariable::IsInScope() {
226 const ExecutionContextRef &exe_ctx_ref = GetExecutionContextRef();
227 if (exe_ctx_ref.HasFrameRef()) {
228 ExecutionContext exe_ctx(exe_ctx_ref);
229 StackFrame *frame = exe_ctx.GetFramePtr();
230 if (frame) {
231 return m_variable_sp->IsInScope(frame);
232 } else {
233 // This ValueObject had a frame at one time, but now we can't locate it,
234 // so return false since we probably aren't in scope.
235 return false;
236 }
237 }
238 // We have a variable that wasn't tied to a frame, which means it is a global
239 // and is always in scope.
240 return true;
241 }
242
GetModule()243 lldb::ModuleSP ValueObjectVariable::GetModule() {
244 if (m_variable_sp) {
245 SymbolContextScope *sc_scope = m_variable_sp->GetSymbolContextScope();
246 if (sc_scope) {
247 return sc_scope->CalculateSymbolContextModule();
248 }
249 }
250 return lldb::ModuleSP();
251 }
252
GetSymbolContextScope()253 SymbolContextScope *ValueObjectVariable::GetSymbolContextScope() {
254 if (m_variable_sp)
255 return m_variable_sp->GetSymbolContextScope();
256 return nullptr;
257 }
258
GetDeclaration(Declaration & decl)259 bool ValueObjectVariable::GetDeclaration(Declaration &decl) {
260 if (m_variable_sp) {
261 decl = m_variable_sp->GetDeclaration();
262 return true;
263 }
264 return false;
265 }
266
GetLocationAsCString()267 const char *ValueObjectVariable::GetLocationAsCString() {
268 if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo)
269 return GetLocationAsCStringImpl(m_resolved_value, m_data);
270 else
271 return ValueObject::GetLocationAsCString();
272 }
273
SetValueFromCString(const char * value_str,Status & error)274 bool ValueObjectVariable::SetValueFromCString(const char *value_str,
275 Status &error) {
276 if (!UpdateValueIfNeeded()) {
277 error.SetErrorString("unable to update value before writing");
278 return false;
279 }
280
281 if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo) {
282 RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo();
283 ExecutionContext exe_ctx(GetExecutionContextRef());
284 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
285 RegisterValue reg_value;
286 if (!reg_info || !reg_ctx) {
287 error.SetErrorString("unable to retrieve register info");
288 return false;
289 }
290 error = reg_value.SetValueFromString(reg_info, llvm::StringRef(value_str));
291 if (error.Fail())
292 return false;
293 if (reg_ctx->WriteRegister(reg_info, reg_value)) {
294 SetNeedsUpdate();
295 return true;
296 } else {
297 error.SetErrorString("unable to write back to register");
298 return false;
299 }
300 } else
301 return ValueObject::SetValueFromCString(value_str, error);
302 }
303
SetData(DataExtractor & data,Status & error)304 bool ValueObjectVariable::SetData(DataExtractor &data, Status &error) {
305 if (!UpdateValueIfNeeded()) {
306 error.SetErrorString("unable to update value before writing");
307 return false;
308 }
309
310 if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo) {
311 RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo();
312 ExecutionContext exe_ctx(GetExecutionContextRef());
313 RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
314 RegisterValue reg_value;
315 if (!reg_info || !reg_ctx) {
316 error.SetErrorString("unable to retrieve register info");
317 return false;
318 }
319 error = reg_value.SetValueFromData(reg_info, data, 0, true);
320 if (error.Fail())
321 return false;
322 if (reg_ctx->WriteRegister(reg_info, reg_value)) {
323 SetNeedsUpdate();
324 return true;
325 } else {
326 error.SetErrorString("unable to write back to register");
327 return false;
328 }
329 } else
330 return ValueObject::SetData(data, error);
331 }
332