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