1 //===-- ValueObjectDynamicValue.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/ValueObjectDynamicValue.h"
10 #include "lldb/Core/Value.h"
11 #include "lldb/Core/ValueObject.h"
12 #include "lldb/Symbol/CompilerType.h"
13 #include "lldb/Symbol/Type.h"
14 #include "lldb/Target/ExecutionContext.h"
15 #include "lldb/Target/LanguageRuntime.h"
16 #include "lldb/Target/Process.h"
17 #include "lldb/Target/Target.h"
18 #include "lldb/Utility/DataExtractor.h"
19 #include "lldb/Utility/Log.h"
20 #include "lldb/Utility/Logging.h"
21 #include "lldb/Utility/Scalar.h"
22 #include "lldb/Utility/Status.h"
23 #include "lldb/lldb-types.h"
24 
25 #include <string.h>
26 namespace lldb_private {
27 class Declaration;
28 }
29 
30 using namespace lldb_private;
31 
32 ValueObjectDynamicValue::ValueObjectDynamicValue(
33     ValueObject &parent, lldb::DynamicValueType use_dynamic)
34     : ValueObject(parent), m_address(), m_dynamic_type_info(),
35       m_use_dynamic(use_dynamic) {
36   SetName(parent.GetName());
37 }
38 
39 ValueObjectDynamicValue::~ValueObjectDynamicValue() {
40   m_owning_valobj_sp.reset();
41 }
42 
43 CompilerType ValueObjectDynamicValue::GetCompilerTypeImpl() {
44   const bool success = UpdateValueIfNeeded(false);
45   if (success) {
46     if (m_dynamic_type_info.HasType())
47       return m_value.GetCompilerType();
48     else
49       return m_parent->GetCompilerType();
50   }
51   return m_parent->GetCompilerType();
52 }
53 
54 ConstString ValueObjectDynamicValue::GetTypeName() {
55   const bool success = UpdateValueIfNeeded(false);
56   if (success) {
57     if (m_dynamic_type_info.HasName())
58       return m_dynamic_type_info.GetName();
59   }
60   return m_parent->GetTypeName();
61 }
62 
63 TypeImpl ValueObjectDynamicValue::GetTypeImpl() {
64   const bool success = UpdateValueIfNeeded(false);
65   if (success && m_type_impl.IsValid()) {
66     return m_type_impl;
67   }
68   return m_parent->GetTypeImpl();
69 }
70 
71 ConstString ValueObjectDynamicValue::GetQualifiedTypeName() {
72   const bool success = UpdateValueIfNeeded(false);
73   if (success) {
74     if (m_dynamic_type_info.HasName())
75       return m_dynamic_type_info.GetName();
76   }
77   return m_parent->GetQualifiedTypeName();
78 }
79 
80 ConstString ValueObjectDynamicValue::GetDisplayTypeName() {
81   const bool success = UpdateValueIfNeeded(false);
82   if (success) {
83     if (m_dynamic_type_info.HasType())
84       return GetCompilerType().GetDisplayTypeName();
85     if (m_dynamic_type_info.HasName())
86       return m_dynamic_type_info.GetName();
87   }
88   return m_parent->GetDisplayTypeName();
89 }
90 
91 size_t ValueObjectDynamicValue::CalculateNumChildren(uint32_t max) {
92   const bool success = UpdateValueIfNeeded(false);
93   if (success && m_dynamic_type_info.HasType()) {
94     ExecutionContext exe_ctx(GetExecutionContextRef());
95     auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
96     return children_count <= max ? children_count : max;
97   } else
98     return m_parent->GetNumChildren(max);
99 }
100 
101 llvm::Optional<uint64_t> ValueObjectDynamicValue::GetByteSize() {
102   const bool success = UpdateValueIfNeeded(false);
103   if (success && m_dynamic_type_info.HasType()) {
104     ExecutionContext exe_ctx(GetExecutionContextRef());
105     return m_value.GetValueByteSize(nullptr, &exe_ctx);
106   } else
107     return m_parent->GetByteSize();
108 }
109 
110 lldb::ValueType ValueObjectDynamicValue::GetValueType() const {
111   return m_parent->GetValueType();
112 }
113 
114 bool ValueObjectDynamicValue::UpdateValue() {
115   SetValueIsValid(false);
116   m_error.Clear();
117 
118   if (!m_parent->UpdateValueIfNeeded(false)) {
119     // The dynamic value failed to get an error, pass the error along
120     if (m_error.Success() && m_parent->GetError().Fail())
121       m_error = m_parent->GetError();
122     return false;
123   }
124 
125   // Setting our type_sp to NULL will route everything back through our parent
126   // which is equivalent to not using dynamic values.
127   if (m_use_dynamic == lldb::eNoDynamicValues) {
128     m_dynamic_type_info.Clear();
129     return true;
130   }
131 
132   ExecutionContext exe_ctx(GetExecutionContextRef());
133   Target *target = exe_ctx.GetTargetPtr();
134   if (target) {
135     m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());
136     m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
137   }
138 
139   // First make sure our Type and/or Address haven't changed:
140   Process *process = exe_ctx.GetProcessPtr();
141   if (!process)
142     return false;
143 
144   TypeAndOrName class_type_or_name;
145   Address dynamic_address;
146   bool found_dynamic_type = false;
147   Value::ValueType value_type;
148 
149   LanguageRuntime *runtime = nullptr;
150 
151   lldb::LanguageType known_type = m_parent->GetObjectRuntimeLanguage();
152   if (known_type != lldb::eLanguageTypeUnknown &&
153       known_type != lldb::eLanguageTypeC) {
154     runtime = process->GetLanguageRuntime(known_type);
155     if (runtime)
156       found_dynamic_type = runtime->GetDynamicTypeAndAddress(
157           *m_parent, m_use_dynamic, class_type_or_name, dynamic_address,
158           value_type);
159   } else {
160     runtime = process->GetLanguageRuntime(lldb::eLanguageTypeC_plus_plus);
161     if (runtime)
162       found_dynamic_type = runtime->GetDynamicTypeAndAddress(
163           *m_parent, m_use_dynamic, class_type_or_name, dynamic_address,
164           value_type);
165 
166     if (!found_dynamic_type) {
167       runtime = process->GetLanguageRuntime(lldb::eLanguageTypeObjC);
168       if (runtime)
169         found_dynamic_type = runtime->GetDynamicTypeAndAddress(
170             *m_parent, m_use_dynamic, class_type_or_name, dynamic_address,
171             value_type);
172     }
173   }
174 
175   // Getting the dynamic value may have run the program a bit, and so marked us
176   // as needing updating, but we really don't...
177 
178   m_update_point.SetUpdated();
179 
180   if (runtime && found_dynamic_type) {
181     if (class_type_or_name.HasType()) {
182       m_type_impl =
183           TypeImpl(m_parent->GetCompilerType(),
184                    runtime->FixUpDynamicType(class_type_or_name, *m_parent)
185                        .GetCompilerType());
186     } else {
187       m_type_impl.Clear();
188     }
189   } else {
190     m_type_impl.Clear();
191   }
192 
193   // If we don't have a dynamic type, then make ourselves just a echo of our
194   // parent. Or we could return false, and make ourselves an echo of our
195   // parent?
196   if (!found_dynamic_type) {
197     if (m_dynamic_type_info)
198       SetValueDidChange(true);
199     ClearDynamicTypeInformation();
200     m_dynamic_type_info.Clear();
201     m_value = m_parent->GetValue();
202     m_error = m_value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
203     return m_error.Success();
204   }
205 
206   Value old_value(m_value);
207 
208   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES));
209 
210   bool has_changed_type = false;
211 
212   if (!m_dynamic_type_info) {
213     m_dynamic_type_info = class_type_or_name;
214     has_changed_type = true;
215   } else if (class_type_or_name != m_dynamic_type_info) {
216     // We are another type, we need to tear down our children...
217     m_dynamic_type_info = class_type_or_name;
218     SetValueDidChange(true);
219     has_changed_type = true;
220   }
221 
222   if (has_changed_type)
223     ClearDynamicTypeInformation();
224 
225   if (!m_address.IsValid() || m_address != dynamic_address) {
226     if (m_address.IsValid())
227       SetValueDidChange(true);
228 
229     // We've moved, so we should be fine...
230     m_address = dynamic_address;
231     lldb::TargetSP target_sp(GetTargetSP());
232     lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get());
233     m_value.GetScalar() = load_address;
234   }
235 
236   if (runtime)
237     m_dynamic_type_info =
238         runtime->FixUpDynamicType(m_dynamic_type_info, *m_parent);
239 
240   m_value.SetCompilerType(m_dynamic_type_info.GetCompilerType());
241 
242   m_value.SetValueType(value_type);
243 
244   if (has_changed_type && log)
245     LLDB_LOGF(log, "[%s %p] has a new dynamic type %s", GetName().GetCString(),
246               static_cast<void *>(this), GetTypeName().GetCString());
247 
248   if (m_address.IsValid() && m_dynamic_type_info) {
249     // The variable value is in the Scalar value inside the m_value. We can
250     // point our m_data right to it.
251     m_error = m_value.GetValueAsData(&exe_ctx, m_data, GetModule().get());
252     if (m_error.Success()) {
253       if (!CanProvideValue()) {
254         // this value object represents an aggregate type whose children have
255         // values, but this object does not. So we say we are changed if our
256         // location has changed.
257         SetValueDidChange(m_value.GetValueType() != old_value.GetValueType() ||
258                           m_value.GetScalar() != old_value.GetScalar());
259       }
260 
261       SetValueIsValid(true);
262       return true;
263     }
264   }
265 
266   // We get here if we've failed above...
267   SetValueIsValid(false);
268   return false;
269 }
270 
271 bool ValueObjectDynamicValue::IsInScope() { return m_parent->IsInScope(); }
272 
273 bool ValueObjectDynamicValue::SetValueFromCString(const char *value_str,
274                                                   Status &error) {
275   if (!UpdateValueIfNeeded(false)) {
276     error.SetErrorString("unable to read value");
277     return false;
278   }
279 
280   uint64_t my_value = GetValueAsUnsigned(UINT64_MAX);
281   uint64_t parent_value = m_parent->GetValueAsUnsigned(UINT64_MAX);
282 
283   if (my_value == UINT64_MAX || parent_value == UINT64_MAX) {
284     error.SetErrorString("unable to read value");
285     return false;
286   }
287 
288   // if we are at an offset from our parent, in order to set ourselves
289   // correctly we would need to change the new value so that it refers to the
290   // correct dynamic type. we choose not to deal with that - if anything more
291   // than a value overwrite is required, you should be using the expression
292   // parser instead of the value editing facility
293   if (my_value != parent_value) {
294     // but NULL'ing out a value should always be allowed
295     if (strcmp(value_str, "0")) {
296       error.SetErrorString(
297           "unable to modify dynamic value, use 'expression' command");
298       return false;
299     }
300   }
301 
302   bool ret_val = m_parent->SetValueFromCString(value_str, error);
303   SetNeedsUpdate();
304   return ret_val;
305 }
306 
307 bool ValueObjectDynamicValue::SetData(DataExtractor &data, Status &error) {
308   if (!UpdateValueIfNeeded(false)) {
309     error.SetErrorString("unable to read value");
310     return false;
311   }
312 
313   uint64_t my_value = GetValueAsUnsigned(UINT64_MAX);
314   uint64_t parent_value = m_parent->GetValueAsUnsigned(UINT64_MAX);
315 
316   if (my_value == UINT64_MAX || parent_value == UINT64_MAX) {
317     error.SetErrorString("unable to read value");
318     return false;
319   }
320 
321   // if we are at an offset from our parent, in order to set ourselves
322   // correctly we would need to change the new value so that it refers to the
323   // correct dynamic type. we choose not to deal with that - if anything more
324   // than a value overwrite is required, you should be using the expression
325   // parser instead of the value editing facility
326   if (my_value != parent_value) {
327     // but NULL'ing out a value should always be allowed
328     lldb::offset_t offset = 0;
329 
330     if (data.GetAddress(&offset) != 0) {
331       error.SetErrorString(
332           "unable to modify dynamic value, use 'expression' command");
333       return false;
334     }
335   }
336 
337   bool ret_val = m_parent->SetData(data, error);
338   SetNeedsUpdate();
339   return ret_val;
340 }
341 
342 void ValueObjectDynamicValue::SetPreferredDisplayLanguage(
343     lldb::LanguageType lang) {
344   this->ValueObject::SetPreferredDisplayLanguage(lang);
345   if (m_parent)
346     m_parent->SetPreferredDisplayLanguage(lang);
347 }
348 
349 lldb::LanguageType ValueObjectDynamicValue::GetPreferredDisplayLanguage() {
350   if (m_preferred_display_language == lldb::eLanguageTypeUnknown) {
351     if (m_parent)
352       return m_parent->GetPreferredDisplayLanguage();
353     return lldb::eLanguageTypeUnknown;
354   } else
355     return m_preferred_display_language;
356 }
357 
358 bool ValueObjectDynamicValue::IsSyntheticChildrenGenerated() {
359   if (m_parent)
360     return m_parent->IsSyntheticChildrenGenerated();
361   return false;
362 }
363 
364 void ValueObjectDynamicValue::SetSyntheticChildrenGenerated(bool b) {
365   if (m_parent)
366     m_parent->SetSyntheticChildrenGenerated(b);
367   this->ValueObject::SetSyntheticChildrenGenerated(b);
368 }
369 
370 bool ValueObjectDynamicValue::GetDeclaration(Declaration &decl) {
371   if (m_parent)
372     return m_parent->GetDeclaration(decl);
373 
374   return ValueObject::GetDeclaration(decl);
375 }
376 
377 uint64_t ValueObjectDynamicValue::GetLanguageFlags() {
378   if (m_parent)
379     return m_parent->GetLanguageFlags();
380   return this->ValueObject::GetLanguageFlags();
381 }
382 
383 void ValueObjectDynamicValue::SetLanguageFlags(uint64_t flags) {
384   if (m_parent)
385     m_parent->SetLanguageFlags(flags);
386   else
387     this->ValueObject::SetLanguageFlags(flags);
388 }
389