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