1 //===-- ValueObject.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 #include "lldb/lldb-python.h"
11 
12 #include "lldb/Core/ValueObject.h"
13 
14 // C Includes
15 #include <stdlib.h>
16 
17 // C++ Includes
18 // Other libraries and framework includes
19 #include "llvm/Support/raw_ostream.h"
20 #include "clang/AST/Type.h"
21 
22 // Project includes
23 #include "lldb/Core/DataBufferHeap.h"
24 #include "lldb/Core/Debugger.h"
25 #include "lldb/Core/Log.h"
26 #include "lldb/Core/Module.h"
27 #include "lldb/Core/StreamString.h"
28 #include "lldb/Core/ValueObjectCast.h"
29 #include "lldb/Core/ValueObjectChild.h"
30 #include "lldb/Core/ValueObjectConstResult.h"
31 #include "lldb/Core/ValueObjectDynamicValue.h"
32 #include "lldb/Core/ValueObjectList.h"
33 #include "lldb/Core/ValueObjectMemory.h"
34 #include "lldb/Core/ValueObjectSyntheticFilter.h"
35 
36 #include "lldb/DataFormatters/DataVisualization.h"
37 #include "lldb/DataFormatters/StringPrinter.h"
38 #include "lldb/DataFormatters/ValueObjectPrinter.h"
39 
40 #include "lldb/Expression/ClangExpressionVariable.h"
41 #include "lldb/Expression/ClangPersistentVariables.h"
42 
43 #include "lldb/Host/Endian.h"
44 
45 #include "lldb/Interpreter/CommandInterpreter.h"
46 #include "lldb/Interpreter/ScriptInterpreterPython.h"
47 
48 #include "lldb/Symbol/ClangASTType.h"
49 #include "lldb/Symbol/ClangASTContext.h"
50 #include "lldb/Symbol/CompileUnit.h"
51 #include "lldb/Symbol/Type.h"
52 
53 #include "lldb/Target/ExecutionContext.h"
54 #include "lldb/Target/LanguageRuntime.h"
55 #include "lldb/Target/ObjCLanguageRuntime.h"
56 #include "lldb/Target/Process.h"
57 #include "lldb/Target/RegisterContext.h"
58 #include "lldb/Target/SectionLoadList.h"
59 #include "lldb/Target/Target.h"
60 #include "lldb/Target/Thread.h"
61 
62 using namespace lldb;
63 using namespace lldb_private;
64 using namespace lldb_utility;
65 
66 static user_id_t g_value_obj_uid = 0;
67 
68 //----------------------------------------------------------------------
69 // ValueObject constructor
70 //----------------------------------------------------------------------
71 ValueObject::ValueObject (ValueObject &parent) :
72     UserID (++g_value_obj_uid), // Unique identifier for every value object
73     m_parent (&parent),
74     m_root (NULL),
75     m_update_point (parent.GetUpdatePoint ()),
76     m_name (),
77     m_data (),
78     m_value (),
79     m_error (),
80     m_value_str (),
81     m_old_value_str (),
82     m_location_str (),
83     m_summary_str (),
84     m_object_desc_str (),
85     m_validation_result(),
86     m_manager(parent.GetManager()),
87     m_children (),
88     m_synthetic_children (),
89     m_dynamic_value (NULL),
90     m_synthetic_value(NULL),
91     m_deref_valobj(NULL),
92     m_format (eFormatDefault),
93     m_last_format (eFormatDefault),
94     m_last_format_mgr_revision(0),
95     m_type_summary_sp(),
96     m_type_format_sp(),
97     m_synthetic_children_sp(),
98     m_type_validator_sp(),
99     m_user_id_of_forced_summary(),
100     m_address_type_of_ptr_or_ref_children(eAddressTypeInvalid),
101     m_value_checksum(),
102     m_preferred_display_language(lldb::eLanguageTypeUnknown),
103     m_value_is_valid (false),
104     m_value_did_change (false),
105     m_children_count_valid (false),
106     m_old_value_valid (false),
107     m_is_deref_of_parent (false),
108     m_is_array_item_for_pointer(false),
109     m_is_bitfield_for_scalar(false),
110     m_is_child_at_offset(false),
111     m_is_getting_summary(false),
112     m_did_calculate_complete_objc_class_type(false),
113     m_is_synthetic_children_generated(parent.m_is_synthetic_children_generated)
114 {
115     m_manager->ManageObject(this);
116 }
117 
118 //----------------------------------------------------------------------
119 // ValueObject constructor
120 //----------------------------------------------------------------------
121 ValueObject::ValueObject (ExecutionContextScope *exe_scope,
122                           AddressType child_ptr_or_ref_addr_type) :
123     UserID (++g_value_obj_uid), // Unique identifier for every value object
124     m_parent (NULL),
125     m_root (NULL),
126     m_update_point (exe_scope),
127     m_name (),
128     m_data (),
129     m_value (),
130     m_error (),
131     m_value_str (),
132     m_old_value_str (),
133     m_location_str (),
134     m_summary_str (),
135     m_object_desc_str (),
136     m_validation_result(),
137     m_manager(),
138     m_children (),
139     m_synthetic_children (),
140     m_dynamic_value (NULL),
141     m_synthetic_value(NULL),
142     m_deref_valobj(NULL),
143     m_format (eFormatDefault),
144     m_last_format (eFormatDefault),
145     m_last_format_mgr_revision(0),
146     m_type_summary_sp(),
147     m_type_format_sp(),
148     m_synthetic_children_sp(),
149     m_type_validator_sp(),
150     m_user_id_of_forced_summary(),
151     m_address_type_of_ptr_or_ref_children(child_ptr_or_ref_addr_type),
152     m_value_checksum(),
153     m_preferred_display_language(lldb::eLanguageTypeUnknown),
154     m_value_is_valid (false),
155     m_value_did_change (false),
156     m_children_count_valid (false),
157     m_old_value_valid (false),
158     m_is_deref_of_parent (false),
159     m_is_array_item_for_pointer(false),
160     m_is_bitfield_for_scalar(false),
161     m_is_child_at_offset(false),
162     m_is_getting_summary(false),
163     m_did_calculate_complete_objc_class_type(false),
164     m_is_synthetic_children_generated(false)
165 {
166     m_manager = new ValueObjectManager();
167     m_manager->ManageObject (this);
168 }
169 
170 //----------------------------------------------------------------------
171 // Destructor
172 //----------------------------------------------------------------------
173 ValueObject::~ValueObject ()
174 {
175 }
176 
177 bool
178 ValueObject::UpdateValueIfNeeded (bool update_format)
179 {
180 
181     bool did_change_formats = false;
182 
183     if (update_format)
184         did_change_formats = UpdateFormatsIfNeeded();
185 
186     // If this is a constant value, then our success is predicated on whether
187     // we have an error or not
188     if (GetIsConstant())
189     {
190         // if you are constant, things might still have changed behind your back
191         // (e.g. you are a frozen object and things have changed deeper than you cared to freeze-dry yourself)
192         // in this case, your value has not changed, but "computed" entries might have, so you might now have
193         // a different summary, or a different object description. clear these so we will recompute them
194         if (update_format && !did_change_formats)
195             ClearUserVisibleData(eClearUserVisibleDataItemsSummary | eClearUserVisibleDataItemsDescription);
196         return m_error.Success();
197     }
198 
199     bool first_update = IsChecksumEmpty();
200 
201     if (NeedsUpdating())
202     {
203         m_update_point.SetUpdated();
204 
205         // Save the old value using swap to avoid a string copy which
206         // also will clear our m_value_str
207         if (m_value_str.empty())
208         {
209             m_old_value_valid = false;
210         }
211         else
212         {
213             m_old_value_valid = true;
214             m_old_value_str.swap (m_value_str);
215             ClearUserVisibleData(eClearUserVisibleDataItemsValue);
216         }
217 
218         ClearUserVisibleData();
219 
220         if (IsInScope())
221         {
222             const bool value_was_valid = GetValueIsValid();
223             SetValueDidChange (false);
224 
225             m_error.Clear();
226 
227             // Call the pure virtual function to update the value
228 
229             bool need_compare_checksums = false;
230             llvm::SmallVector<uint8_t, 16> old_checksum;
231 
232             if (!first_update && CanProvideValue())
233             {
234                 need_compare_checksums = true;
235                 old_checksum.resize(m_value_checksum.size());
236                 std::copy(m_value_checksum.begin(), m_value_checksum.end(), old_checksum.begin());
237             }
238 
239             bool success = UpdateValue ();
240 
241             SetValueIsValid (success);
242 
243             if (success)
244             {
245                 const uint64_t max_checksum_size = 128;
246                 m_data.Checksum(m_value_checksum,
247                                 max_checksum_size);
248             }
249             else
250             {
251                 need_compare_checksums = false;
252                 m_value_checksum.clear();
253             }
254 
255             assert (!need_compare_checksums || (!old_checksum.empty() && !m_value_checksum.empty()));
256 
257             if (first_update)
258                 SetValueDidChange (false);
259             else if (!m_value_did_change && success == false)
260             {
261                 // The value wasn't gotten successfully, so we mark this
262                 // as changed if the value used to be valid and now isn't
263                 SetValueDidChange (value_was_valid);
264             }
265             else if (need_compare_checksums)
266             {
267                 SetValueDidChange(memcmp(&old_checksum[0], &m_value_checksum[0], m_value_checksum.size()));
268             }
269 
270         }
271         else
272         {
273             m_error.SetErrorString("out of scope");
274         }
275     }
276     return m_error.Success();
277 }
278 
279 bool
280 ValueObject::UpdateFormatsIfNeeded()
281 {
282     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
283     if (log)
284         log->Printf("[%s %p] checking for FormatManager revisions. ValueObject rev: %d - Global rev: %d",
285                     GetName().GetCString(), static_cast<void*>(this),
286                     m_last_format_mgr_revision,
287                     DataVisualization::GetCurrentRevision());
288 
289     bool any_change = false;
290 
291     if ( (m_last_format_mgr_revision != DataVisualization::GetCurrentRevision()))
292     {
293         m_last_format_mgr_revision = DataVisualization::GetCurrentRevision();
294         any_change = true;
295 
296         SetValueFormat(DataVisualization::GetFormat (*this, eNoDynamicValues));
297         SetSummaryFormat(DataVisualization::GetSummaryFormat (*this, GetDynamicValueType()));
298 #ifndef LLDB_DISABLE_PYTHON
299         SetSyntheticChildren(DataVisualization::GetSyntheticChildren (*this, GetDynamicValueType()));
300 #endif
301         SetValidator(DataVisualization::GetValidator(*this, GetDynamicValueType()));
302     }
303 
304     return any_change;
305 }
306 
307 void
308 ValueObject::SetNeedsUpdate ()
309 {
310     m_update_point.SetNeedsUpdate();
311     // We have to clear the value string here so ConstResult children will notice if their values are
312     // changed by hand (i.e. with SetValueAsCString).
313     ClearUserVisibleData(eClearUserVisibleDataItemsValue);
314 }
315 
316 void
317 ValueObject::ClearDynamicTypeInformation ()
318 {
319     m_children_count_valid = false;
320     m_did_calculate_complete_objc_class_type = false;
321     m_last_format_mgr_revision = 0;
322     m_override_type = ClangASTType();
323     SetValueFormat(lldb::TypeFormatImplSP());
324     SetSummaryFormat(lldb::TypeSummaryImplSP());
325     SetSyntheticChildren(lldb::SyntheticChildrenSP());
326 }
327 
328 ClangASTType
329 ValueObject::MaybeCalculateCompleteType ()
330 {
331     ClangASTType clang_type(GetClangTypeImpl());
332 
333     if (m_did_calculate_complete_objc_class_type)
334     {
335         if (m_override_type.IsValid())
336             return m_override_type;
337         else
338             return clang_type;
339     }
340 
341     ClangASTType class_type;
342     bool is_pointer_type = false;
343 
344     if (clang_type.IsObjCObjectPointerType(&class_type))
345     {
346         is_pointer_type = true;
347     }
348     else if (clang_type.IsObjCObjectOrInterfaceType())
349     {
350         class_type = clang_type;
351     }
352     else
353     {
354         return clang_type;
355     }
356 
357     m_did_calculate_complete_objc_class_type = true;
358 
359     if (class_type)
360     {
361         ConstString class_name (class_type.GetConstTypeName());
362 
363         if (class_name)
364         {
365             ProcessSP process_sp(GetUpdatePoint().GetExecutionContextRef().GetProcessSP());
366 
367             if (process_sp)
368             {
369                 ObjCLanguageRuntime *objc_language_runtime(process_sp->GetObjCLanguageRuntime());
370 
371                 if (objc_language_runtime)
372                 {
373                     TypeSP complete_objc_class_type_sp = objc_language_runtime->LookupInCompleteClassCache(class_name);
374 
375                     if (complete_objc_class_type_sp)
376                     {
377                         ClangASTType complete_class(complete_objc_class_type_sp->GetClangFullType());
378 
379                         if (complete_class.GetCompleteType())
380                         {
381                             if (is_pointer_type)
382                             {
383                                 m_override_type = complete_class.GetPointerType();
384                             }
385                             else
386                             {
387                                 m_override_type = complete_class;
388                             }
389 
390                             if (m_override_type.IsValid())
391                                 return m_override_type;
392                         }
393                     }
394                 }
395             }
396         }
397     }
398     return clang_type;
399 }
400 
401 ClangASTType
402 ValueObject::GetClangType ()
403 {
404     return MaybeCalculateCompleteType();
405 }
406 
407 TypeImpl
408 ValueObject::GetTypeImpl ()
409 {
410     return TypeImpl(GetClangType());
411 }
412 
413 DataExtractor &
414 ValueObject::GetDataExtractor ()
415 {
416     UpdateValueIfNeeded(false);
417     return m_data;
418 }
419 
420 const Error &
421 ValueObject::GetError()
422 {
423     UpdateValueIfNeeded(false);
424     return m_error;
425 }
426 
427 const ConstString &
428 ValueObject::GetName() const
429 {
430     return m_name;
431 }
432 
433 const char *
434 ValueObject::GetLocationAsCString ()
435 {
436     return GetLocationAsCStringImpl(m_value,
437                                     m_data);
438 }
439 
440 const char *
441 ValueObject::GetLocationAsCStringImpl (const Value& value,
442                                        const DataExtractor& data)
443 {
444     if (UpdateValueIfNeeded(false))
445     {
446         if (m_location_str.empty())
447         {
448             StreamString sstr;
449 
450             Value::ValueType value_type = value.GetValueType();
451 
452             switch (value_type)
453             {
454             case Value::eValueTypeScalar:
455             case Value::eValueTypeVector:
456                 if (value.GetContextType() == Value::eContextTypeRegisterInfo)
457                 {
458                     RegisterInfo *reg_info = value.GetRegisterInfo();
459                     if (reg_info)
460                     {
461                         if (reg_info->name)
462                             m_location_str = reg_info->name;
463                         else if (reg_info->alt_name)
464                             m_location_str = reg_info->alt_name;
465                         if (m_location_str.empty())
466                             m_location_str = (reg_info->encoding == lldb::eEncodingVector) ? "vector" : "scalar";
467                     }
468                 }
469                 if (m_location_str.empty())
470                     m_location_str = (value_type == Value::eValueTypeVector) ? "vector" : "scalar";
471                 break;
472 
473             case Value::eValueTypeLoadAddress:
474             case Value::eValueTypeFileAddress:
475             case Value::eValueTypeHostAddress:
476                 {
477                     uint32_t addr_nibble_size = data.GetAddressByteSize() * 2;
478                     sstr.Printf("0x%*.*llx", addr_nibble_size, addr_nibble_size, value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS));
479                     m_location_str.swap(sstr.GetString());
480                 }
481                 break;
482             }
483         }
484     }
485     return m_location_str.c_str();
486 }
487 
488 Value &
489 ValueObject::GetValue()
490 {
491     return m_value;
492 }
493 
494 const Value &
495 ValueObject::GetValue() const
496 {
497     return m_value;
498 }
499 
500 bool
501 ValueObject::ResolveValue (Scalar &scalar)
502 {
503     if (UpdateValueIfNeeded(false)) // make sure that you are up to date before returning anything
504     {
505         ExecutionContext exe_ctx (GetExecutionContextRef());
506         Value tmp_value(m_value);
507         scalar = tmp_value.ResolveValue(&exe_ctx);
508         if (scalar.IsValid())
509         {
510             const uint32_t bitfield_bit_size = GetBitfieldBitSize();
511             if (bitfield_bit_size)
512                 return scalar.ExtractBitfield (bitfield_bit_size, GetBitfieldBitOffset());
513             return true;
514         }
515     }
516     return false;
517 }
518 
519 bool
520 ValueObject::GetValueIsValid () const
521 {
522     return m_value_is_valid;
523 }
524 
525 
526 void
527 ValueObject::SetValueIsValid (bool b)
528 {
529     m_value_is_valid = b;
530 }
531 
532 bool
533 ValueObject::GetValueDidChange ()
534 {
535     return m_value_did_change;
536 }
537 
538 void
539 ValueObject::SetValueDidChange (bool value_changed)
540 {
541     m_value_did_change = value_changed;
542 }
543 
544 ValueObjectSP
545 ValueObject::GetChildAtIndex (size_t idx, bool can_create)
546 {
547     ValueObjectSP child_sp;
548     // We may need to update our value if we are dynamic
549     if (IsPossibleDynamicType ())
550         UpdateValueIfNeeded(false);
551     if (idx < GetNumChildren())
552     {
553         // Check if we have already made the child value object?
554         if (can_create && !m_children.HasChildAtIndex(idx))
555         {
556             // No we haven't created the child at this index, so lets have our
557             // subclass do it and cache the result for quick future access.
558             m_children.SetChildAtIndex(idx,CreateChildAtIndex (idx, false, 0));
559         }
560 
561         ValueObject* child = m_children.GetChildAtIndex(idx);
562         if (child != NULL)
563             return child->GetSP();
564     }
565     return child_sp;
566 }
567 
568 ValueObjectSP
569 ValueObject::GetChildAtIndexPath (const std::initializer_list<size_t>& idxs,
570                                   size_t* index_of_error)
571 {
572     if (idxs.size() == 0)
573         return GetSP();
574     ValueObjectSP root(GetSP());
575     for (size_t idx : idxs)
576     {
577         root = root->GetChildAtIndex(idx, true);
578         if (!root)
579         {
580             if (index_of_error)
581                 *index_of_error = idx;
582             return root;
583         }
584     }
585     return root;
586 }
587 
588 ValueObjectSP
589 ValueObject::GetChildAtIndexPath (const std::initializer_list< std::pair<size_t, bool> >& idxs,
590                                   size_t* index_of_error)
591 {
592     if (idxs.size() == 0)
593         return GetSP();
594     ValueObjectSP root(GetSP());
595     for (std::pair<size_t, bool> idx : idxs)
596     {
597         root = root->GetChildAtIndex(idx.first, idx.second);
598         if (!root)
599         {
600             if (index_of_error)
601                 *index_of_error = idx.first;
602             return root;
603         }
604     }
605     return root;
606 }
607 
608 lldb::ValueObjectSP
609 ValueObject::GetChildAtIndexPath (const std::vector<size_t> &idxs,
610                                   size_t* index_of_error)
611 {
612     if (idxs.size() == 0)
613         return GetSP();
614     ValueObjectSP root(GetSP());
615     for (size_t idx : idxs)
616     {
617         root = root->GetChildAtIndex(idx, true);
618         if (!root)
619         {
620             if (index_of_error)
621                 *index_of_error = idx;
622             return root;
623         }
624     }
625     return root;
626 }
627 
628 lldb::ValueObjectSP
629 ValueObject::GetChildAtIndexPath (const std::vector< std::pair<size_t, bool> > &idxs,
630                                   size_t* index_of_error)
631 {
632     if (idxs.size() == 0)
633         return GetSP();
634     ValueObjectSP root(GetSP());
635     for (std::pair<size_t, bool> idx : idxs)
636     {
637         root = root->GetChildAtIndex(idx.first, idx.second);
638         if (!root)
639         {
640             if (index_of_error)
641                 *index_of_error = idx.first;
642             return root;
643         }
644     }
645     return root;
646 }
647 
648 lldb::ValueObjectSP
649 ValueObject::GetChildAtNamePath (const std::initializer_list<ConstString> &names,
650                                  ConstString* name_of_error)
651 {
652     if (names.size() == 0)
653         return GetSP();
654     ValueObjectSP root(GetSP());
655     for (ConstString name : names)
656     {
657         root = root->GetChildMemberWithName(name, true);
658         if (!root)
659         {
660             if (name_of_error)
661                 *name_of_error = name;
662             return root;
663         }
664     }
665     return root;
666 }
667 
668 lldb::ValueObjectSP
669 ValueObject::GetChildAtNamePath (const std::vector<ConstString> &names,
670                                  ConstString* name_of_error)
671 {
672     if (names.size() == 0)
673         return GetSP();
674     ValueObjectSP root(GetSP());
675     for (ConstString name : names)
676     {
677         root = root->GetChildMemberWithName(name, true);
678         if (!root)
679         {
680             if (name_of_error)
681                 *name_of_error = name;
682             return root;
683         }
684     }
685     return root;
686 }
687 
688 lldb::ValueObjectSP
689 ValueObject::GetChildAtNamePath (const std::initializer_list< std::pair<ConstString, bool> > &names,
690                                  ConstString* name_of_error)
691 {
692     if (names.size() == 0)
693         return GetSP();
694     ValueObjectSP root(GetSP());
695     for (std::pair<ConstString, bool> name : names)
696     {
697         root = root->GetChildMemberWithName(name.first, name.second);
698         if (!root)
699         {
700             if (name_of_error)
701                 *name_of_error = name.first;
702             return root;
703         }
704     }
705     return root;
706 }
707 
708 lldb::ValueObjectSP
709 ValueObject::GetChildAtNamePath (const std::vector< std::pair<ConstString, bool> > &names,
710                                  ConstString* name_of_error)
711 {
712     if (names.size() == 0)
713         return GetSP();
714         ValueObjectSP root(GetSP());
715         for (std::pair<ConstString, bool> name : names)
716         {
717             root = root->GetChildMemberWithName(name.first, name.second);
718             if (!root)
719             {
720                 if (name_of_error)
721                     *name_of_error = name.first;
722                     return root;
723             }
724         }
725     return root;
726 }
727 
728 size_t
729 ValueObject::GetIndexOfChildWithName (const ConstString &name)
730 {
731     bool omit_empty_base_classes = true;
732     return GetClangType().GetIndexOfChildWithName (name.GetCString(), omit_empty_base_classes);
733 }
734 
735 ValueObjectSP
736 ValueObject::GetChildMemberWithName (const ConstString &name, bool can_create)
737 {
738     // when getting a child by name, it could be buried inside some base
739     // classes (which really aren't part of the expression path), so we
740     // need a vector of indexes that can get us down to the correct child
741     ValueObjectSP child_sp;
742 
743     // We may need to update our value if we are dynamic
744     if (IsPossibleDynamicType ())
745         UpdateValueIfNeeded(false);
746 
747     std::vector<uint32_t> child_indexes;
748     bool omit_empty_base_classes = true;
749     const size_t num_child_indexes =  GetClangType().GetIndexOfChildMemberWithName (name.GetCString(),
750                                                                                     omit_empty_base_classes,
751                                                                                     child_indexes);
752     if (num_child_indexes > 0)
753     {
754         std::vector<uint32_t>::const_iterator pos = child_indexes.begin ();
755         std::vector<uint32_t>::const_iterator end = child_indexes.end ();
756 
757         child_sp = GetChildAtIndex(*pos, can_create);
758         for (++pos; pos != end; ++pos)
759         {
760             if (child_sp)
761             {
762                 ValueObjectSP new_child_sp(child_sp->GetChildAtIndex (*pos, can_create));
763                 child_sp = new_child_sp;
764             }
765             else
766             {
767                 child_sp.reset();
768             }
769 
770         }
771     }
772     return child_sp;
773 }
774 
775 
776 size_t
777 ValueObject::GetNumChildren ()
778 {
779     UpdateValueIfNeeded();
780     if (!m_children_count_valid)
781     {
782         SetNumChildren (CalculateNumChildren());
783     }
784     return m_children.GetChildrenCount();
785 }
786 
787 bool
788 ValueObject::MightHaveChildren()
789 {
790     bool has_children = false;
791     const uint32_t type_info = GetTypeInfo();
792     if (type_info)
793     {
794         if (type_info & (eTypeHasChildren |
795                          eTypeIsPointer |
796                          eTypeIsReference))
797             has_children = true;
798     }
799     else
800     {
801         has_children = GetNumChildren () > 0;
802     }
803     return has_children;
804 }
805 
806 // Should only be called by ValueObject::GetNumChildren()
807 void
808 ValueObject::SetNumChildren (size_t num_children)
809 {
810     m_children_count_valid = true;
811     m_children.SetChildrenCount(num_children);
812 }
813 
814 void
815 ValueObject::SetName (const ConstString &name)
816 {
817     m_name = name;
818 }
819 
820 ValueObject *
821 ValueObject::CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index)
822 {
823     ValueObject *valobj = NULL;
824 
825     bool omit_empty_base_classes = true;
826     bool ignore_array_bounds = synthetic_array_member;
827     std::string child_name_str;
828     uint32_t child_byte_size = 0;
829     int32_t child_byte_offset = 0;
830     uint32_t child_bitfield_bit_size = 0;
831     uint32_t child_bitfield_bit_offset = 0;
832     bool child_is_base_class = false;
833     bool child_is_deref_of_parent = false;
834 
835     const bool transparent_pointers = synthetic_array_member == false;
836     ClangASTType child_clang_type;
837 
838     ExecutionContext exe_ctx (GetExecutionContextRef());
839 
840     child_clang_type = GetClangType().GetChildClangTypeAtIndex (&exe_ctx,
841                                                                 idx,
842                                                                 transparent_pointers,
843                                                                 omit_empty_base_classes,
844                                                                 ignore_array_bounds,
845                                                                 child_name_str,
846                                                                 child_byte_size,
847                                                                 child_byte_offset,
848                                                                 child_bitfield_bit_size,
849                                                                 child_bitfield_bit_offset,
850                                                                 child_is_base_class,
851                                                                 child_is_deref_of_parent,
852                                                                 this);
853     if (child_clang_type)
854     {
855         if (synthetic_index)
856             child_byte_offset += child_byte_size * synthetic_index;
857 
858         ConstString child_name;
859         if (!child_name_str.empty())
860             child_name.SetCString (child_name_str.c_str());
861 
862         valobj = new ValueObjectChild (*this,
863                                        child_clang_type,
864                                        child_name,
865                                        child_byte_size,
866                                        child_byte_offset,
867                                        child_bitfield_bit_size,
868                                        child_bitfield_bit_offset,
869                                        child_is_base_class,
870                                        child_is_deref_of_parent,
871                                        eAddressTypeInvalid);
872         //if (valobj)
873         //    valobj->SetAddressTypeOfChildren(eAddressTypeInvalid);
874    }
875 
876     return valobj;
877 }
878 
879 bool
880 ValueObject::GetSummaryAsCString (TypeSummaryImpl* summary_ptr,
881                                   std::string& destination)
882 {
883     return GetSummaryAsCString(summary_ptr, destination, TypeSummaryOptions());
884 }
885 
886 bool
887 ValueObject::GetSummaryAsCString (TypeSummaryImpl* summary_ptr,
888                                   std::string& destination,
889                                   const TypeSummaryOptions& options)
890 {
891     destination.clear();
892 
893     // ideally we would like to bail out if passing NULL, but if we do so
894     // we end up not providing the summary for function pointers anymore
895     if (/*summary_ptr == NULL ||*/ m_is_getting_summary)
896         return false;
897 
898     m_is_getting_summary = true;
899 
900     // this is a hot path in code and we prefer to avoid setting this string all too often also clearing out other
901     // information that we might care to see in a crash log. might be useful in very specific situations though.
902     /*Host::SetCrashDescriptionWithFormat("Trying to fetch a summary for %s %s. Summary provider's description is %s",
903                                         GetTypeName().GetCString(),
904                                         GetName().GetCString(),
905                                         summary_ptr->GetDescription().c_str());*/
906 
907     if (UpdateValueIfNeeded (false) && summary_ptr)
908     {
909         if (HasSyntheticValue())
910             m_synthetic_value->UpdateValueIfNeeded(); // the summary might depend on the synthetic children being up-to-date (e.g. ${svar%#})
911         summary_ptr->FormatObject(this, destination, options);
912     }
913     m_is_getting_summary = false;
914     return !destination.empty();
915 }
916 
917 const char *
918 ValueObject::GetSummaryAsCString ()
919 {
920     if (UpdateValueIfNeeded(true) && m_summary_str.empty())
921     {
922         GetSummaryAsCString(GetSummaryFormat().get(),
923                             m_summary_str,
924                             TypeSummaryOptions());
925     }
926     if (m_summary_str.empty())
927         return NULL;
928     return m_summary_str.c_str();
929 }
930 
931 bool
932 ValueObject::GetSummaryAsCString (std::string& destination,
933                                   const TypeSummaryOptions& options)
934 {
935     return GetSummaryAsCString(GetSummaryFormat().get(),
936                         destination,
937                         options);
938 }
939 
940 bool
941 ValueObject::IsCStringContainer(bool check_pointer)
942 {
943     ClangASTType pointee_or_element_clang_type;
944     const Flags type_flags (GetTypeInfo (&pointee_or_element_clang_type));
945     bool is_char_arr_ptr (type_flags.AnySet (eTypeIsArray | eTypeIsPointer) &&
946                           pointee_or_element_clang_type.IsCharType ());
947     if (!is_char_arr_ptr)
948         return false;
949     if (!check_pointer)
950         return true;
951     if (type_flags.Test(eTypeIsArray))
952         return true;
953     addr_t cstr_address = LLDB_INVALID_ADDRESS;
954     AddressType cstr_address_type = eAddressTypeInvalid;
955     cstr_address = GetAddressOf (true, &cstr_address_type);
956     return (cstr_address != LLDB_INVALID_ADDRESS);
957 }
958 
959 size_t
960 ValueObject::GetPointeeData (DataExtractor& data,
961                              uint32_t item_idx,
962                              uint32_t item_count)
963 {
964     ClangASTType pointee_or_element_clang_type;
965     const uint32_t type_info = GetTypeInfo (&pointee_or_element_clang_type);
966     const bool is_pointer_type = type_info & eTypeIsPointer;
967     const bool is_array_type = type_info & eTypeIsArray;
968     if (!(is_pointer_type || is_array_type))
969         return 0;
970 
971     if (item_count == 0)
972         return 0;
973 
974     ExecutionContext exe_ctx (GetExecutionContextRef());
975 
976     const uint64_t item_type_size = pointee_or_element_clang_type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
977     const uint64_t bytes = item_count * item_type_size;
978     const uint64_t offset = item_idx * item_type_size;
979 
980     if (item_idx == 0 && item_count == 1) // simply a deref
981     {
982         if (is_pointer_type)
983         {
984             Error error;
985             ValueObjectSP pointee_sp = Dereference(error);
986             if (error.Fail() || pointee_sp.get() == NULL)
987                 return 0;
988             return pointee_sp->GetData(data, error);
989         }
990         else
991         {
992             ValueObjectSP child_sp = GetChildAtIndex(0, true);
993             if (child_sp.get() == NULL)
994                 return 0;
995             Error error;
996             return child_sp->GetData(data, error);
997         }
998         return true;
999     }
1000     else /* (items > 1) */
1001     {
1002         Error error;
1003         lldb_private::DataBufferHeap* heap_buf_ptr = NULL;
1004         lldb::DataBufferSP data_sp(heap_buf_ptr = new lldb_private::DataBufferHeap());
1005 
1006         AddressType addr_type;
1007         lldb::addr_t addr = is_pointer_type ? GetPointerValue(&addr_type) : GetAddressOf(true, &addr_type);
1008 
1009         switch (addr_type)
1010         {
1011             case eAddressTypeFile:
1012                 {
1013                     ModuleSP module_sp (GetModule());
1014                     if (module_sp)
1015                     {
1016                         addr = addr + offset;
1017                         Address so_addr;
1018                         module_sp->ResolveFileAddress(addr, so_addr);
1019                         ExecutionContext exe_ctx (GetExecutionContextRef());
1020                         Target* target = exe_ctx.GetTargetPtr();
1021                         if (target)
1022                         {
1023                             heap_buf_ptr->SetByteSize(bytes);
1024                             size_t bytes_read = target->ReadMemory(so_addr, false, heap_buf_ptr->GetBytes(), bytes, error);
1025                             if (error.Success())
1026                             {
1027                                 data.SetData(data_sp);
1028                                 return bytes_read;
1029                             }
1030                         }
1031                     }
1032                 }
1033                 break;
1034             case eAddressTypeLoad:
1035                 {
1036                     ExecutionContext exe_ctx (GetExecutionContextRef());
1037                     Process *process = exe_ctx.GetProcessPtr();
1038                     if (process)
1039                     {
1040                         heap_buf_ptr->SetByteSize(bytes);
1041                         size_t bytes_read = process->ReadMemory(addr + offset, heap_buf_ptr->GetBytes(), bytes, error);
1042                         if (error.Success() || bytes_read > 0)
1043                         {
1044                             data.SetData(data_sp);
1045                             return bytes_read;
1046                         }
1047                     }
1048                 }
1049                 break;
1050             case eAddressTypeHost:
1051                 {
1052                     const uint64_t max_bytes = GetClangType().GetByteSize(exe_ctx.GetBestExecutionContextScope());
1053                     if (max_bytes > offset)
1054                     {
1055                         size_t bytes_read = std::min<uint64_t>(max_bytes - offset, bytes);
1056                         addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1057                         if (addr == LLDB_INVALID_ADDRESS)
1058                             break;
1059                         heap_buf_ptr->CopyData((uint8_t*)(addr + offset), bytes_read);
1060                         data.SetData(data_sp);
1061                         return bytes_read;
1062                     }
1063                 }
1064                 break;
1065             case eAddressTypeInvalid:
1066                 break;
1067         }
1068     }
1069     return 0;
1070 }
1071 
1072 uint64_t
1073 ValueObject::GetData (DataExtractor& data, Error &error)
1074 {
1075     UpdateValueIfNeeded(false);
1076     ExecutionContext exe_ctx (GetExecutionContextRef());
1077     error = m_value.GetValueAsData(&exe_ctx, data, 0, GetModule().get());
1078     if (error.Fail())
1079     {
1080         if (m_data.GetByteSize())
1081         {
1082             data = m_data;
1083             return data.GetByteSize();
1084         }
1085         else
1086         {
1087             return 0;
1088         }
1089     }
1090     data.SetAddressByteSize(m_data.GetAddressByteSize());
1091     data.SetByteOrder(m_data.GetByteOrder());
1092     return data.GetByteSize();
1093 }
1094 
1095 bool
1096 ValueObject::SetData (DataExtractor &data, Error &error)
1097 {
1098     error.Clear();
1099     // Make sure our value is up to date first so that our location and location
1100     // type is valid.
1101     if (!UpdateValueIfNeeded(false))
1102     {
1103         error.SetErrorString("unable to read value");
1104         return false;
1105     }
1106 
1107     uint64_t count = 0;
1108     const Encoding encoding = GetClangType().GetEncoding(count);
1109 
1110     const size_t byte_size = GetByteSize();
1111 
1112     Value::ValueType value_type = m_value.GetValueType();
1113 
1114     switch (value_type)
1115     {
1116     case Value::eValueTypeScalar:
1117         {
1118             Error set_error = m_value.GetScalar().SetValueFromData(data, encoding, byte_size);
1119 
1120             if (!set_error.Success())
1121             {
1122                 error.SetErrorStringWithFormat("unable to set scalar value: %s", set_error.AsCString());
1123                 return false;
1124             }
1125         }
1126         break;
1127     case Value::eValueTypeLoadAddress:
1128         {
1129             // If it is a load address, then the scalar value is the storage location
1130             // of the data, and we have to shove this value down to that load location.
1131             ExecutionContext exe_ctx (GetExecutionContextRef());
1132             Process *process = exe_ctx.GetProcessPtr();
1133             if (process)
1134             {
1135                 addr_t target_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1136                 size_t bytes_written = process->WriteMemory(target_addr,
1137                                                             data.GetDataStart(),
1138                                                             byte_size,
1139                                                             error);
1140                 if (!error.Success())
1141                     return false;
1142                 if (bytes_written != byte_size)
1143                 {
1144                     error.SetErrorString("unable to write value to memory");
1145                     return false;
1146                 }
1147             }
1148         }
1149         break;
1150     case Value::eValueTypeHostAddress:
1151         {
1152             // If it is a host address, then we stuff the scalar as a DataBuffer into the Value's data.
1153             DataBufferSP buffer_sp (new DataBufferHeap(byte_size, 0));
1154             m_data.SetData(buffer_sp, 0);
1155             data.CopyByteOrderedData (0,
1156                                       byte_size,
1157                                       const_cast<uint8_t *>(m_data.GetDataStart()),
1158                                       byte_size,
1159                                       m_data.GetByteOrder());
1160             m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
1161         }
1162         break;
1163     case Value::eValueTypeFileAddress:
1164     case Value::eValueTypeVector:
1165         break;
1166     }
1167 
1168     // If we have reached this point, then we have successfully changed the value.
1169     SetNeedsUpdate();
1170     return true;
1171 }
1172 
1173 // will compute strlen(str), but without consuming more than
1174 // maxlen bytes out of str (this serves the purpose of reading
1175 // chunks of a string without having to worry about
1176 // missing NULL terminators in the chunk)
1177 // of course, if strlen(str) > maxlen, the function will return
1178 // maxlen_value (which should be != maxlen, because that allows you
1179 // to know whether strlen(str) == maxlen or strlen(str) > maxlen)
1180 static uint32_t
1181 strlen_or_inf (const char* str,
1182                uint32_t maxlen,
1183                uint32_t maxlen_value)
1184 {
1185     uint32_t len = 0;
1186     if (str)
1187     {
1188         while(*str)
1189         {
1190             len++;str++;
1191             if (len >= maxlen)
1192                 return maxlen_value;
1193         }
1194     }
1195     return len;
1196 }
1197 
1198 static bool
1199 CopyStringDataToBufferSP(const StreamString& source,
1200                          lldb::DataBufferSP& destination)
1201 {
1202     destination.reset(new DataBufferHeap(source.GetSize()+1,0));
1203     memcpy(destination->GetBytes(), source.GetString().c_str(), source.GetSize());
1204     return true;
1205 }
1206 
1207 size_t
1208 ValueObject::ReadPointedString (lldb::DataBufferSP& buffer_sp,
1209                                 Error& error,
1210                                 uint32_t max_length,
1211                                 bool honor_array,
1212                                 Format item_format)
1213 {
1214     StreamString s;
1215     ExecutionContext exe_ctx (GetExecutionContextRef());
1216     Target* target = exe_ctx.GetTargetPtr();
1217 
1218     if (!target)
1219     {
1220         s << "<no target to read from>";
1221         error.SetErrorString("no target to read from");
1222         CopyStringDataToBufferSP(s, buffer_sp);
1223         return 0;
1224     }
1225 
1226     if (max_length == 0)
1227         max_length = target->GetMaximumSizeOfStringSummary();
1228 
1229     size_t bytes_read = 0;
1230     size_t total_bytes_read = 0;
1231 
1232     ClangASTType clang_type = GetClangType();
1233     ClangASTType elem_or_pointee_clang_type;
1234     const Flags type_flags (GetTypeInfo (&elem_or_pointee_clang_type));
1235     if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer) &&
1236         elem_or_pointee_clang_type.IsCharType ())
1237     {
1238         addr_t cstr_address = LLDB_INVALID_ADDRESS;
1239         AddressType cstr_address_type = eAddressTypeInvalid;
1240 
1241         size_t cstr_len = 0;
1242         bool capped_data = false;
1243         if (type_flags.Test (eTypeIsArray))
1244         {
1245             // We have an array
1246             uint64_t array_size = 0;
1247             if (clang_type.IsArrayType(NULL, &array_size, NULL))
1248             {
1249                 cstr_len = array_size;
1250                 if (cstr_len > max_length)
1251                 {
1252                     capped_data = true;
1253                     cstr_len = max_length;
1254                 }
1255             }
1256             cstr_address = GetAddressOf (true, &cstr_address_type);
1257         }
1258         else
1259         {
1260             // We have a pointer
1261             cstr_address = GetPointerValue (&cstr_address_type);
1262         }
1263 
1264         if (cstr_address == 0 || cstr_address == LLDB_INVALID_ADDRESS)
1265         {
1266             s << "<invalid address>";
1267             error.SetErrorString("invalid address");
1268             CopyStringDataToBufferSP(s, buffer_sp);
1269             return 0;
1270         }
1271 
1272         Address cstr_so_addr (cstr_address);
1273         DataExtractor data;
1274         if (cstr_len > 0 && honor_array)
1275         {
1276             // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host
1277             // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this
1278             GetPointeeData(data, 0, cstr_len);
1279 
1280             if ((bytes_read = data.GetByteSize()) > 0)
1281             {
1282                 total_bytes_read = bytes_read;
1283                 for (size_t offset = 0; offset < bytes_read; offset++)
1284                     s.Printf("%c", *data.PeekData(offset, 1));
1285                 if (capped_data)
1286                     s << "...";
1287             }
1288         }
1289         else
1290         {
1291             cstr_len = max_length;
1292             const size_t k_max_buf_size = 64;
1293 
1294             size_t offset = 0;
1295 
1296             int cstr_len_displayed = -1;
1297             bool capped_cstr = false;
1298             // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host
1299             // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this
1300             while ((bytes_read = GetPointeeData(data, offset, k_max_buf_size)) > 0)
1301             {
1302                 total_bytes_read += bytes_read;
1303                 const char *cstr = data.PeekCStr(0);
1304                 size_t len = strlen_or_inf (cstr, k_max_buf_size, k_max_buf_size+1);
1305                 if (len > k_max_buf_size)
1306                     len = k_max_buf_size;
1307 
1308                 if (cstr_len_displayed < 0)
1309                     cstr_len_displayed = len;
1310 
1311                 if (len == 0)
1312                     break;
1313                 cstr_len_displayed += len;
1314                 if (len > bytes_read)
1315                     len = bytes_read;
1316                 if (len > cstr_len)
1317                     len = cstr_len;
1318 
1319                 for (size_t offset = 0; offset < bytes_read; offset++)
1320                     s.Printf("%c", *data.PeekData(offset, 1));
1321 
1322                 if (len < k_max_buf_size)
1323                     break;
1324 
1325                 if (len >= cstr_len)
1326                 {
1327                     capped_cstr = true;
1328                     break;
1329                 }
1330 
1331                 cstr_len -= len;
1332                 offset += len;
1333             }
1334 
1335             if (cstr_len_displayed >= 0)
1336             {
1337                 if (capped_cstr)
1338                     s << "...";
1339             }
1340         }
1341     }
1342     else
1343     {
1344         error.SetErrorString("not a string object");
1345         s << "<not a string object>";
1346     }
1347     CopyStringDataToBufferSP(s, buffer_sp);
1348     return total_bytes_read;
1349 }
1350 
1351 std::pair<TypeValidatorResult, std::string>
1352 ValueObject::GetValidationStatus ()
1353 {
1354     if (!UpdateValueIfNeeded(true))
1355         return {TypeValidatorResult::Success,""}; // not the validator's job to discuss update problems
1356 
1357     if (m_validation_result.hasValue())
1358         return m_validation_result.getValue();
1359 
1360     if (!m_type_validator_sp)
1361         return {TypeValidatorResult::Success,""}; // no validator no failure
1362 
1363     auto outcome = m_type_validator_sp->FormatObject(this);
1364 
1365     return (m_validation_result = {outcome.m_result,outcome.m_message}).getValue();
1366 }
1367 
1368 const char *
1369 ValueObject::GetObjectDescription ()
1370 {
1371 
1372     if (!UpdateValueIfNeeded (true))
1373         return NULL;
1374 
1375     if (!m_object_desc_str.empty())
1376         return m_object_desc_str.c_str();
1377 
1378     ExecutionContext exe_ctx (GetExecutionContextRef());
1379     Process *process = exe_ctx.GetProcessPtr();
1380     if (process == NULL)
1381         return NULL;
1382 
1383     StreamString s;
1384 
1385     LanguageType language = GetObjectRuntimeLanguage();
1386     LanguageRuntime *runtime = process->GetLanguageRuntime(language);
1387 
1388     if (runtime == NULL)
1389     {
1390         // Aw, hell, if the things a pointer, or even just an integer, let's try ObjC anyway...
1391         ClangASTType clang_type = GetClangType();
1392         if (clang_type)
1393         {
1394             bool is_signed;
1395             if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType ())
1396             {
1397                 runtime = process->GetLanguageRuntime(eLanguageTypeObjC);
1398             }
1399         }
1400     }
1401 
1402     if (runtime && runtime->GetObjectDescription(s, *this))
1403     {
1404         m_object_desc_str.append (s.GetData());
1405     }
1406 
1407     if (m_object_desc_str.empty())
1408         return NULL;
1409     else
1410         return m_object_desc_str.c_str();
1411 }
1412 
1413 bool
1414 ValueObject::GetValueAsCString (const lldb_private::TypeFormatImpl& format,
1415                                 std::string& destination)
1416 {
1417     if (UpdateValueIfNeeded(false))
1418         return format.FormatObject(this,destination);
1419     else
1420         return false;
1421 }
1422 
1423 bool
1424 ValueObject::GetValueAsCString (lldb::Format format,
1425                                 std::string& destination)
1426 {
1427     return GetValueAsCString(TypeFormatImpl_Format(format),destination);
1428 }
1429 
1430 const char *
1431 ValueObject::GetValueAsCString ()
1432 {
1433     if (UpdateValueIfNeeded(true))
1434     {
1435         lldb::TypeFormatImplSP format_sp;
1436         lldb::Format my_format = GetFormat();
1437         if (my_format == lldb::eFormatDefault)
1438         {
1439             if (m_type_format_sp)
1440                 format_sp = m_type_format_sp;
1441             else
1442             {
1443                 if (m_is_bitfield_for_scalar)
1444                     my_format = eFormatUnsigned;
1445                 else
1446                 {
1447                     if (m_value.GetContextType() == Value::eContextTypeRegisterInfo)
1448                     {
1449                         const RegisterInfo *reg_info = m_value.GetRegisterInfo();
1450                         if (reg_info)
1451                             my_format = reg_info->format;
1452                     }
1453                     else
1454                     {
1455                         my_format = GetValue().GetClangType().GetFormat();
1456                     }
1457                 }
1458             }
1459         }
1460         if (my_format != m_last_format || m_value_str.empty())
1461         {
1462             m_last_format = my_format;
1463             if (!format_sp)
1464                 format_sp.reset(new TypeFormatImpl_Format(my_format));
1465             if (GetValueAsCString(*format_sp.get(), m_value_str))
1466             {
1467                 if (!m_value_did_change && m_old_value_valid)
1468                 {
1469                     // The value was gotten successfully, so we consider the
1470                     // value as changed if the value string differs
1471                     SetValueDidChange (m_old_value_str != m_value_str);
1472                 }
1473             }
1474         }
1475     }
1476     if (m_value_str.empty())
1477         return NULL;
1478     return m_value_str.c_str();
1479 }
1480 
1481 // if > 8bytes, 0 is returned. this method should mostly be used
1482 // to read address values out of pointers
1483 uint64_t
1484 ValueObject::GetValueAsUnsigned (uint64_t fail_value, bool *success)
1485 {
1486     // If our byte size is zero this is an aggregate type that has children
1487     if (CanProvideValue())
1488     {
1489         Scalar scalar;
1490         if (ResolveValue (scalar))
1491         {
1492             if (success)
1493                 *success = true;
1494             return scalar.ULongLong(fail_value);
1495         }
1496         // fallthrough, otherwise...
1497     }
1498 
1499     if (success)
1500         *success = false;
1501     return fail_value;
1502 }
1503 
1504 int64_t
1505 ValueObject::GetValueAsSigned (int64_t fail_value, bool *success)
1506 {
1507     // If our byte size is zero this is an aggregate type that has children
1508     if (CanProvideValue())
1509     {
1510         Scalar scalar;
1511         if (ResolveValue (scalar))
1512         {
1513             if (success)
1514                 *success = true;
1515             return scalar.SLongLong(fail_value);
1516         }
1517         // fallthrough, otherwise...
1518     }
1519 
1520     if (success)
1521         *success = false;
1522     return fail_value;
1523 }
1524 
1525 // if any more "special cases" are added to ValueObject::DumpPrintableRepresentation() please keep
1526 // this call up to date by returning true for your new special cases. We will eventually move
1527 // to checking this call result before trying to display special cases
1528 bool
1529 ValueObject::HasSpecialPrintableRepresentation(ValueObjectRepresentationStyle val_obj_display,
1530                                                Format custom_format)
1531 {
1532     Flags flags(GetTypeInfo());
1533     if (flags.AnySet(eTypeIsArray | eTypeIsPointer)
1534         && val_obj_display == ValueObject::eValueObjectRepresentationStyleValue)
1535     {
1536         if (IsCStringContainer(true) &&
1537             (custom_format == eFormatCString ||
1538              custom_format == eFormatCharArray ||
1539              custom_format == eFormatChar ||
1540              custom_format == eFormatVectorOfChar))
1541             return true;
1542 
1543         if (flags.Test(eTypeIsArray))
1544         {
1545             if ((custom_format == eFormatBytes) ||
1546                 (custom_format == eFormatBytesWithASCII))
1547                 return true;
1548 
1549             if ((custom_format == eFormatVectorOfChar) ||
1550                 (custom_format == eFormatVectorOfFloat32) ||
1551                 (custom_format == eFormatVectorOfFloat64) ||
1552                 (custom_format == eFormatVectorOfSInt16) ||
1553                 (custom_format == eFormatVectorOfSInt32) ||
1554                 (custom_format == eFormatVectorOfSInt64) ||
1555                 (custom_format == eFormatVectorOfSInt8) ||
1556                 (custom_format == eFormatVectorOfUInt128) ||
1557                 (custom_format == eFormatVectorOfUInt16) ||
1558                 (custom_format == eFormatVectorOfUInt32) ||
1559                 (custom_format == eFormatVectorOfUInt64) ||
1560                 (custom_format == eFormatVectorOfUInt8))
1561                 return true;
1562         }
1563     }
1564     return false;
1565 }
1566 
1567 bool
1568 ValueObject::DumpPrintableRepresentation(Stream& s,
1569                                          ValueObjectRepresentationStyle val_obj_display,
1570                                          Format custom_format,
1571                                          PrintableRepresentationSpecialCases special,
1572                                          bool do_dump_error)
1573 {
1574 
1575     Flags flags(GetTypeInfo());
1576 
1577     bool allow_special = ((special & ePrintableRepresentationSpecialCasesAllow) == ePrintableRepresentationSpecialCasesAllow);
1578     bool only_special = ((special & ePrintableRepresentationSpecialCasesOnly) == ePrintableRepresentationSpecialCasesOnly);
1579 
1580     if (allow_special)
1581     {
1582         if (flags.AnySet(eTypeIsArray | eTypeIsPointer)
1583              && val_obj_display == ValueObject::eValueObjectRepresentationStyleValue)
1584         {
1585             // when being asked to get a printable display an array or pointer type directly,
1586             // try to "do the right thing"
1587 
1588             if (IsCStringContainer(true) &&
1589                 (custom_format == eFormatCString ||
1590                  custom_format == eFormatCharArray ||
1591                  custom_format == eFormatChar ||
1592                  custom_format == eFormatVectorOfChar)) // print char[] & char* directly
1593             {
1594                 Error error;
1595                 lldb::DataBufferSP buffer_sp;
1596                 ReadPointedString(buffer_sp,
1597                                   error,
1598                                   0,
1599                                   (custom_format == eFormatVectorOfChar) ||
1600                                   (custom_format == eFormatCharArray));
1601                 lldb_private::formatters::ReadBufferAndDumpToStreamOptions options(*this);
1602                 options.SetData(DataExtractor(buffer_sp, lldb::eByteOrderInvalid, 8)); // none of this matters for a string - pass some defaults
1603                 options.SetStream(&s);
1604                 options.SetPrefixToken(0);
1605                 options.SetQuote('"');
1606                 options.SetSourceSize(buffer_sp->GetByteSize());
1607                 lldb_private::formatters::ReadBufferAndDumpToStream<lldb_private::formatters::StringElementType::ASCII>(options);
1608                 return !error.Fail();
1609             }
1610 
1611             if (custom_format == eFormatEnum)
1612                 return false;
1613 
1614             // this only works for arrays, because I have no way to know when
1615             // the pointed memory ends, and no special \0 end of data marker
1616             if (flags.Test(eTypeIsArray))
1617             {
1618                 if ((custom_format == eFormatBytes) ||
1619                     (custom_format == eFormatBytesWithASCII))
1620                 {
1621                     const size_t count = GetNumChildren();
1622 
1623                     s << '[';
1624                     for (size_t low = 0; low < count; low++)
1625                     {
1626 
1627                         if (low)
1628                             s << ',';
1629 
1630                         ValueObjectSP child = GetChildAtIndex(low,true);
1631                         if (!child.get())
1632                         {
1633                             s << "<invalid child>";
1634                             continue;
1635                         }
1636                         child->DumpPrintableRepresentation(s, ValueObject::eValueObjectRepresentationStyleValue, custom_format);
1637                     }
1638 
1639                     s << ']';
1640 
1641                     return true;
1642                 }
1643 
1644                 if ((custom_format == eFormatVectorOfChar) ||
1645                     (custom_format == eFormatVectorOfFloat32) ||
1646                     (custom_format == eFormatVectorOfFloat64) ||
1647                     (custom_format == eFormatVectorOfSInt16) ||
1648                     (custom_format == eFormatVectorOfSInt32) ||
1649                     (custom_format == eFormatVectorOfSInt64) ||
1650                     (custom_format == eFormatVectorOfSInt8) ||
1651                     (custom_format == eFormatVectorOfUInt128) ||
1652                     (custom_format == eFormatVectorOfUInt16) ||
1653                     (custom_format == eFormatVectorOfUInt32) ||
1654                     (custom_format == eFormatVectorOfUInt64) ||
1655                     (custom_format == eFormatVectorOfUInt8)) // arrays of bytes, bytes with ASCII or any vector format should be printed directly
1656                 {
1657                     const size_t count = GetNumChildren();
1658 
1659                     Format format = FormatManager::GetSingleItemFormat(custom_format);
1660 
1661                     s << '[';
1662                     for (size_t low = 0; low < count; low++)
1663                     {
1664 
1665                         if (low)
1666                             s << ',';
1667 
1668                         ValueObjectSP child = GetChildAtIndex(low,true);
1669                         if (!child.get())
1670                         {
1671                             s << "<invalid child>";
1672                             continue;
1673                         }
1674                         child->DumpPrintableRepresentation(s, ValueObject::eValueObjectRepresentationStyleValue, format);
1675                     }
1676 
1677                     s << ']';
1678 
1679                     return true;
1680                 }
1681             }
1682 
1683             if ((custom_format == eFormatBoolean) ||
1684                 (custom_format == eFormatBinary) ||
1685                 (custom_format == eFormatChar) ||
1686                 (custom_format == eFormatCharPrintable) ||
1687                 (custom_format == eFormatComplexFloat) ||
1688                 (custom_format == eFormatDecimal) ||
1689                 (custom_format == eFormatHex) ||
1690                 (custom_format == eFormatHexUppercase) ||
1691                 (custom_format == eFormatFloat) ||
1692                 (custom_format == eFormatOctal) ||
1693                 (custom_format == eFormatOSType) ||
1694                 (custom_format == eFormatUnicode16) ||
1695                 (custom_format == eFormatUnicode32) ||
1696                 (custom_format == eFormatUnsigned) ||
1697                 (custom_format == eFormatPointer) ||
1698                 (custom_format == eFormatComplexInteger) ||
1699                 (custom_format == eFormatComplex) ||
1700                 (custom_format == eFormatDefault)) // use the [] operator
1701                 return false;
1702         }
1703     }
1704 
1705     if (only_special)
1706         return false;
1707 
1708     bool var_success = false;
1709 
1710     {
1711         const char *cstr = NULL;
1712 
1713          // this is a local stream that we are using to ensure that the data pointed to by cstr survives
1714         // long enough for us to copy it to its destination - it is necessary to have this temporary storage
1715         // area for cases where our desired output is not backed by some other longer-term storage
1716         StreamString strm;
1717 
1718         if (custom_format != eFormatInvalid)
1719             SetFormat(custom_format);
1720 
1721         switch(val_obj_display)
1722         {
1723             case eValueObjectRepresentationStyleValue:
1724                 cstr = GetValueAsCString();
1725                 break;
1726 
1727             case eValueObjectRepresentationStyleSummary:
1728                 cstr = GetSummaryAsCString();
1729                 break;
1730 
1731             case eValueObjectRepresentationStyleLanguageSpecific:
1732                 cstr = GetObjectDescription();
1733                 break;
1734 
1735             case eValueObjectRepresentationStyleLocation:
1736                 cstr = GetLocationAsCString();
1737                 break;
1738 
1739             case eValueObjectRepresentationStyleChildrenCount:
1740                 strm.Printf("%" PRIu64 "", (uint64_t)GetNumChildren());
1741                 cstr = strm.GetString().c_str();
1742                 break;
1743 
1744             case eValueObjectRepresentationStyleType:
1745                 cstr = GetTypeName().AsCString();
1746                 break;
1747 
1748             case eValueObjectRepresentationStyleName:
1749                 cstr = GetName().AsCString();
1750                 break;
1751 
1752             case eValueObjectRepresentationStyleExpressionPath:
1753                 GetExpressionPath(strm, false);
1754                 cstr = strm.GetString().c_str();
1755                 break;
1756         }
1757 
1758         if (!cstr)
1759         {
1760             if (val_obj_display == eValueObjectRepresentationStyleValue)
1761                 cstr = GetSummaryAsCString();
1762             else if (val_obj_display == eValueObjectRepresentationStyleSummary)
1763             {
1764                 if (!CanProvideValue())
1765                 {
1766                     strm.Printf("%s @ %s", GetTypeName().AsCString(), GetLocationAsCString());
1767                     cstr = strm.GetString().c_str();
1768                 }
1769                 else
1770                     cstr = GetValueAsCString();
1771             }
1772         }
1773 
1774         if (cstr)
1775             s.PutCString(cstr);
1776         else
1777         {
1778             if (m_error.Fail())
1779             {
1780                 if (do_dump_error)
1781                     s.Printf("<%s>", m_error.AsCString());
1782                 else
1783                     return false;
1784             }
1785             else if (val_obj_display == eValueObjectRepresentationStyleSummary)
1786                 s.PutCString("<no summary available>");
1787             else if (val_obj_display == eValueObjectRepresentationStyleValue)
1788                 s.PutCString("<no value available>");
1789             else if (val_obj_display == eValueObjectRepresentationStyleLanguageSpecific)
1790                 s.PutCString("<not a valid Objective-C object>"); // edit this if we have other runtimes that support a description
1791             else
1792                 s.PutCString("<no printable representation>");
1793         }
1794 
1795         // we should only return false here if we could not do *anything*
1796         // even if we have an error message as output, that's a success
1797         // from our callers' perspective, so return true
1798         var_success = true;
1799 
1800         if (custom_format != eFormatInvalid)
1801             SetFormat(eFormatDefault);
1802     }
1803 
1804     return var_success;
1805 }
1806 
1807 addr_t
1808 ValueObject::GetAddressOf (bool scalar_is_load_address, AddressType *address_type)
1809 {
1810     if (!UpdateValueIfNeeded(false))
1811         return LLDB_INVALID_ADDRESS;
1812 
1813     switch (m_value.GetValueType())
1814     {
1815     case Value::eValueTypeScalar:
1816     case Value::eValueTypeVector:
1817         if (scalar_is_load_address)
1818         {
1819             if(address_type)
1820                 *address_type = eAddressTypeLoad;
1821             return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1822         }
1823         break;
1824 
1825     case Value::eValueTypeLoadAddress:
1826     case Value::eValueTypeFileAddress:
1827         {
1828             if(address_type)
1829                 *address_type = m_value.GetValueAddressType ();
1830             return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1831         }
1832         break;
1833     case Value::eValueTypeHostAddress:
1834         {
1835             if(address_type)
1836                 *address_type = m_value.GetValueAddressType ();
1837             return LLDB_INVALID_ADDRESS;
1838         }
1839         break;
1840     }
1841     if (address_type)
1842         *address_type = eAddressTypeInvalid;
1843     return LLDB_INVALID_ADDRESS;
1844 }
1845 
1846 addr_t
1847 ValueObject::GetPointerValue (AddressType *address_type)
1848 {
1849     addr_t address = LLDB_INVALID_ADDRESS;
1850     if(address_type)
1851         *address_type = eAddressTypeInvalid;
1852 
1853     if (!UpdateValueIfNeeded(false))
1854         return address;
1855 
1856     switch (m_value.GetValueType())
1857     {
1858     case Value::eValueTypeScalar:
1859     case Value::eValueTypeVector:
1860         address = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1861         break;
1862 
1863     case Value::eValueTypeHostAddress:
1864     case Value::eValueTypeLoadAddress:
1865     case Value::eValueTypeFileAddress:
1866         {
1867             lldb::offset_t data_offset = 0;
1868             address = m_data.GetPointer(&data_offset);
1869         }
1870         break;
1871     }
1872 
1873     if (address_type)
1874         *address_type = GetAddressTypeOfChildren();
1875 
1876     return address;
1877 }
1878 
1879 bool
1880 ValueObject::SetValueFromCString (const char *value_str, Error& error)
1881 {
1882     error.Clear();
1883     // Make sure our value is up to date first so that our location and location
1884     // type is valid.
1885     if (!UpdateValueIfNeeded(false))
1886     {
1887         error.SetErrorString("unable to read value");
1888         return false;
1889     }
1890 
1891     uint64_t count = 0;
1892     const Encoding encoding = GetClangType().GetEncoding (count);
1893 
1894     const size_t byte_size = GetByteSize();
1895 
1896     Value::ValueType value_type = m_value.GetValueType();
1897 
1898     if (value_type == Value::eValueTypeScalar)
1899     {
1900         // If the value is already a scalar, then let the scalar change itself:
1901         m_value.GetScalar().SetValueFromCString (value_str, encoding, byte_size);
1902     }
1903     else if (byte_size <= Scalar::GetMaxByteSize())
1904     {
1905         // If the value fits in a scalar, then make a new scalar and again let the
1906         // scalar code do the conversion, then figure out where to put the new value.
1907         Scalar new_scalar;
1908         error = new_scalar.SetValueFromCString (value_str, encoding, byte_size);
1909         if (error.Success())
1910         {
1911             switch (value_type)
1912             {
1913             case Value::eValueTypeLoadAddress:
1914                 {
1915                     // If it is a load address, then the scalar value is the storage location
1916                     // of the data, and we have to shove this value down to that load location.
1917                     ExecutionContext exe_ctx (GetExecutionContextRef());
1918                     Process *process = exe_ctx.GetProcessPtr();
1919                     if (process)
1920                     {
1921                         addr_t target_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1922                         size_t bytes_written = process->WriteScalarToMemory (target_addr,
1923                                                                              new_scalar,
1924                                                                              byte_size,
1925                                                                              error);
1926                         if (!error.Success())
1927                             return false;
1928                         if (bytes_written != byte_size)
1929                         {
1930                             error.SetErrorString("unable to write value to memory");
1931                             return false;
1932                         }
1933                     }
1934                 }
1935                 break;
1936             case Value::eValueTypeHostAddress:
1937                 {
1938                     // If it is a host address, then we stuff the scalar as a DataBuffer into the Value's data.
1939                     DataExtractor new_data;
1940                     new_data.SetByteOrder (m_data.GetByteOrder());
1941 
1942                     DataBufferSP buffer_sp (new DataBufferHeap(byte_size, 0));
1943                     m_data.SetData(buffer_sp, 0);
1944                     bool success = new_scalar.GetData(new_data);
1945                     if (success)
1946                     {
1947                         new_data.CopyByteOrderedData (0,
1948                                                       byte_size,
1949                                                       const_cast<uint8_t *>(m_data.GetDataStart()),
1950                                                       byte_size,
1951                                                       m_data.GetByteOrder());
1952                     }
1953                     m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
1954 
1955                 }
1956                 break;
1957             case Value::eValueTypeFileAddress:
1958             case Value::eValueTypeScalar:
1959             case Value::eValueTypeVector:
1960                 break;
1961             }
1962         }
1963         else
1964         {
1965             return false;
1966         }
1967     }
1968     else
1969     {
1970         // We don't support setting things bigger than a scalar at present.
1971         error.SetErrorString("unable to write aggregate data type");
1972         return false;
1973     }
1974 
1975     // If we have reached this point, then we have successfully changed the value.
1976     SetNeedsUpdate();
1977     return true;
1978 }
1979 
1980 bool
1981 ValueObject::GetDeclaration (Declaration &decl)
1982 {
1983     decl.Clear();
1984     return false;
1985 }
1986 
1987 ConstString
1988 ValueObject::GetTypeName()
1989 {
1990     return GetClangType().GetConstTypeName();
1991 }
1992 
1993 ConstString
1994 ValueObject::GetDisplayTypeName()
1995 {
1996     return GetTypeName();
1997 }
1998 
1999 ConstString
2000 ValueObject::GetQualifiedTypeName()
2001 {
2002     return GetClangType().GetConstQualifiedTypeName();
2003 }
2004 
2005 
2006 LanguageType
2007 ValueObject::GetObjectRuntimeLanguage ()
2008 {
2009     return GetClangType().GetMinimumLanguage ();
2010 }
2011 
2012 void
2013 ValueObject::AddSyntheticChild (const ConstString &key, ValueObject *valobj)
2014 {
2015     m_synthetic_children[key] = valobj;
2016 }
2017 
2018 ValueObjectSP
2019 ValueObject::GetSyntheticChild (const ConstString &key) const
2020 {
2021     ValueObjectSP synthetic_child_sp;
2022     std::map<ConstString, ValueObject *>::const_iterator pos = m_synthetic_children.find (key);
2023     if (pos != m_synthetic_children.end())
2024         synthetic_child_sp = pos->second->GetSP();
2025     return synthetic_child_sp;
2026 }
2027 
2028 uint32_t
2029 ValueObject::GetTypeInfo (ClangASTType *pointee_or_element_clang_type)
2030 {
2031     return GetClangType().GetTypeInfo (pointee_or_element_clang_type);
2032 }
2033 
2034 bool
2035 ValueObject::IsPointerType ()
2036 {
2037     return GetClangType().IsPointerType();
2038 }
2039 
2040 bool
2041 ValueObject::IsArrayType ()
2042 {
2043     return GetClangType().IsArrayType (NULL, NULL, NULL);
2044 }
2045 
2046 bool
2047 ValueObject::IsScalarType ()
2048 {
2049     return GetClangType().IsScalarType ();
2050 }
2051 
2052 bool
2053 ValueObject::IsIntegerType (bool &is_signed)
2054 {
2055     return GetClangType().IsIntegerType (is_signed);
2056 }
2057 
2058 bool
2059 ValueObject::IsPointerOrReferenceType ()
2060 {
2061     return GetClangType().IsPointerOrReferenceType ();
2062 }
2063 
2064 bool
2065 ValueObject::IsPossibleDynamicType ()
2066 {
2067     ExecutionContext exe_ctx (GetExecutionContextRef());
2068     Process *process = exe_ctx.GetProcessPtr();
2069     if (process)
2070         return process->IsPossibleDynamicValue(*this);
2071     else
2072         return GetClangType().IsPossibleDynamicType (NULL, true, true);
2073 }
2074 
2075 bool
2076 ValueObject::IsRuntimeSupportValue ()
2077 {
2078     Process *process(GetProcessSP().get());
2079     if (process)
2080     {
2081         LanguageRuntime *runtime = process->GetLanguageRuntime(GetObjectRuntimeLanguage());
2082         if (!runtime)
2083             runtime = process->GetObjCLanguageRuntime();
2084         if (runtime)
2085             return runtime->IsRuntimeSupportValue(*this);
2086     }
2087     return false;
2088 }
2089 
2090 bool
2091 ValueObject::IsObjCNil ()
2092 {
2093     const uint32_t mask = eTypeIsObjC | eTypeIsPointer;
2094     bool isObjCpointer = (((GetClangType().GetTypeInfo(NULL)) & mask) == mask);
2095     if (!isObjCpointer)
2096         return false;
2097     bool canReadValue = true;
2098     bool isZero = GetValueAsUnsigned(0,&canReadValue) == 0;
2099     return canReadValue && isZero;
2100 }
2101 
2102 // This allows you to create an array member using and index
2103 // that doesn't not fall in the normal bounds of the array.
2104 // Many times structure can be defined as:
2105 // struct Collection
2106 // {
2107 //     uint32_t item_count;
2108 //     Item item_array[0];
2109 // };
2110 // The size of the "item_array" is 1, but many times in practice
2111 // there are more items in "item_array".
2112 
2113 ValueObjectSP
2114 ValueObject::GetSyntheticArrayMember (size_t index, bool can_create)
2115 {
2116     ValueObjectSP synthetic_child_sp;
2117     if (IsPointerType () || IsArrayType())
2118     {
2119         char index_str[64];
2120         snprintf(index_str, sizeof(index_str), "[%" PRIu64 "]", (uint64_t)index);
2121         ConstString index_const_str(index_str);
2122         // Check if we have already created a synthetic array member in this
2123         // valid object. If we have we will re-use it.
2124         synthetic_child_sp = GetSyntheticChild (index_const_str);
2125         if (!synthetic_child_sp)
2126         {
2127             ValueObject *synthetic_child;
2128             // We haven't made a synthetic array member for INDEX yet, so
2129             // lets make one and cache it for any future reference.
2130             synthetic_child = CreateChildAtIndex(0, true, index);
2131 
2132             // Cache the value if we got one back...
2133             if (synthetic_child)
2134             {
2135                 AddSyntheticChild(index_const_str, synthetic_child);
2136                 synthetic_child_sp = synthetic_child->GetSP();
2137                 synthetic_child_sp->SetName(ConstString(index_str));
2138                 synthetic_child_sp->m_is_array_item_for_pointer = true;
2139             }
2140         }
2141     }
2142     return synthetic_child_sp;
2143 }
2144 
2145 ValueObjectSP
2146 ValueObject::GetSyntheticBitFieldChild (uint32_t from, uint32_t to, bool can_create)
2147 {
2148     ValueObjectSP synthetic_child_sp;
2149     if (IsScalarType ())
2150     {
2151         char index_str[64];
2152         snprintf(index_str, sizeof(index_str), "[%i-%i]", from, to);
2153         ConstString index_const_str(index_str);
2154         // Check if we have already created a synthetic array member in this
2155         // valid object. If we have we will re-use it.
2156         synthetic_child_sp = GetSyntheticChild (index_const_str);
2157         if (!synthetic_child_sp)
2158         {
2159             // We haven't made a synthetic array member for INDEX yet, so
2160             // lets make one and cache it for any future reference.
2161             ValueObjectChild *synthetic_child = new ValueObjectChild (*this,
2162                                                                       GetClangType(),
2163                                                                       index_const_str,
2164                                                                       GetByteSize(),
2165                                                                       0,
2166                                                                       to-from+1,
2167                                                                       from,
2168                                                                       false,
2169                                                                       false,
2170                                                                       eAddressTypeInvalid);
2171 
2172             // Cache the value if we got one back...
2173             if (synthetic_child)
2174             {
2175                 AddSyntheticChild(index_const_str, synthetic_child);
2176                 synthetic_child_sp = synthetic_child->GetSP();
2177                 synthetic_child_sp->SetName(ConstString(index_str));
2178                 synthetic_child_sp->m_is_bitfield_for_scalar = true;
2179             }
2180         }
2181     }
2182     return synthetic_child_sp;
2183 }
2184 
2185 ValueObjectSP
2186 ValueObject::GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create)
2187 {
2188 
2189     ValueObjectSP synthetic_child_sp;
2190 
2191     char name_str[64];
2192     snprintf(name_str, sizeof(name_str), "@%i", offset);
2193     ConstString name_const_str(name_str);
2194 
2195     // Check if we have already created a synthetic array member in this
2196     // valid object. If we have we will re-use it.
2197     synthetic_child_sp = GetSyntheticChild (name_const_str);
2198 
2199     if (synthetic_child_sp.get())
2200         return synthetic_child_sp;
2201 
2202     if (!can_create)
2203         return ValueObjectSP();
2204 
2205     ExecutionContext exe_ctx (GetExecutionContextRef());
2206 
2207     ValueObjectChild *synthetic_child = new ValueObjectChild(*this,
2208                                                              type,
2209                                                              name_const_str,
2210                                                              type.GetByteSize(exe_ctx.GetBestExecutionContextScope()),
2211                                                              offset,
2212                                                              0,
2213                                                              0,
2214                                                              false,
2215                                                              false,
2216                                                              eAddressTypeInvalid);
2217     if (synthetic_child)
2218     {
2219         AddSyntheticChild(name_const_str, synthetic_child);
2220         synthetic_child_sp = synthetic_child->GetSP();
2221         synthetic_child_sp->SetName(name_const_str);
2222         synthetic_child_sp->m_is_child_at_offset = true;
2223     }
2224     return synthetic_child_sp;
2225 }
2226 
2227 ValueObjectSP
2228 ValueObject::GetSyntheticBase (uint32_t offset, const ClangASTType& type, bool can_create)
2229 {
2230     ValueObjectSP synthetic_child_sp;
2231 
2232     char name_str[64];
2233     snprintf(name_str, sizeof(name_str), "%s", type.GetTypeName().AsCString("<unknown>"));
2234     ConstString name_const_str(name_str);
2235 
2236     // Check if we have already created a synthetic array member in this
2237     // valid object. If we have we will re-use it.
2238     synthetic_child_sp = GetSyntheticChild (name_const_str);
2239 
2240     if (synthetic_child_sp.get())
2241         return synthetic_child_sp;
2242 
2243     if (!can_create)
2244         return ValueObjectSP();
2245 
2246     const bool is_base_class = true;
2247 
2248     ExecutionContext exe_ctx (GetExecutionContextRef());
2249 
2250     ValueObjectChild *synthetic_child = new ValueObjectChild(*this,
2251                                                              type,
2252                                                              name_const_str,
2253                                                              type.GetByteSize(exe_ctx.GetBestExecutionContextScope()),
2254                                                              offset,
2255                                                              0,
2256                                                              0,
2257                                                              is_base_class,
2258                                                              false,
2259                                                              eAddressTypeInvalid);
2260     if (synthetic_child)
2261     {
2262         AddSyntheticChild(name_const_str, synthetic_child);
2263         synthetic_child_sp = synthetic_child->GetSP();
2264         synthetic_child_sp->SetName(name_const_str);
2265     }
2266     return synthetic_child_sp;
2267 }
2268 
2269 
2270 // your expression path needs to have a leading . or ->
2271 // (unless it somehow "looks like" an array, in which case it has
2272 // a leading [ symbol). while the [ is meaningful and should be shown
2273 // to the user, . and -> are just parser design, but by no means
2274 // added information for the user.. strip them off
2275 static const char*
2276 SkipLeadingExpressionPathSeparators(const char* expression)
2277 {
2278     if (!expression || !expression[0])
2279         return expression;
2280     if (expression[0] == '.')
2281         return expression+1;
2282     if (expression[0] == '-' && expression[1] == '>')
2283         return expression+2;
2284     return expression;
2285 }
2286 
2287 ValueObjectSP
2288 ValueObject::GetSyntheticExpressionPathChild(const char* expression, bool can_create)
2289 {
2290     ValueObjectSP synthetic_child_sp;
2291     ConstString name_const_string(expression);
2292     // Check if we have already created a synthetic array member in this
2293     // valid object. If we have we will re-use it.
2294     synthetic_child_sp = GetSyntheticChild (name_const_string);
2295     if (!synthetic_child_sp)
2296     {
2297         // We haven't made a synthetic array member for expression yet, so
2298         // lets make one and cache it for any future reference.
2299         synthetic_child_sp = GetValueForExpressionPath(expression,
2300                                                        NULL, NULL, NULL,
2301                                                        GetValueForExpressionPathOptions().SetSyntheticChildrenTraversal(GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None));
2302 
2303         // Cache the value if we got one back...
2304         if (synthetic_child_sp.get())
2305         {
2306             // FIXME: this causes a "real" child to end up with its name changed to the contents of expression
2307             AddSyntheticChild(name_const_string, synthetic_child_sp.get());
2308             synthetic_child_sp->SetName(ConstString(SkipLeadingExpressionPathSeparators(expression)));
2309         }
2310     }
2311     return synthetic_child_sp;
2312 }
2313 
2314 void
2315 ValueObject::CalculateSyntheticValue (bool use_synthetic)
2316 {
2317     if (use_synthetic == false)
2318         return;
2319 
2320     TargetSP target_sp(GetTargetSP());
2321     if (target_sp && target_sp->GetEnableSyntheticValue() == false)
2322     {
2323         m_synthetic_value = NULL;
2324         return;
2325     }
2326 
2327     lldb::SyntheticChildrenSP current_synth_sp(m_synthetic_children_sp);
2328 
2329     if (!UpdateFormatsIfNeeded() && m_synthetic_value)
2330         return;
2331 
2332     if (m_synthetic_children_sp.get() == NULL)
2333         return;
2334 
2335     if (current_synth_sp == m_synthetic_children_sp && m_synthetic_value)
2336         return;
2337 
2338     m_synthetic_value = new ValueObjectSynthetic(*this, m_synthetic_children_sp);
2339 }
2340 
2341 void
2342 ValueObject::CalculateDynamicValue (DynamicValueType use_dynamic)
2343 {
2344     if (use_dynamic == eNoDynamicValues)
2345         return;
2346 
2347     if (!m_dynamic_value && !IsDynamic())
2348     {
2349         ExecutionContext exe_ctx (GetExecutionContextRef());
2350         Process *process = exe_ctx.GetProcessPtr();
2351         if (process && process->IsPossibleDynamicValue(*this))
2352         {
2353             ClearDynamicTypeInformation ();
2354             m_dynamic_value = new ValueObjectDynamicValue (*this, use_dynamic);
2355         }
2356     }
2357 }
2358 
2359 ValueObjectSP
2360 ValueObject::GetDynamicValue (DynamicValueType use_dynamic)
2361 {
2362     if (use_dynamic == eNoDynamicValues)
2363         return ValueObjectSP();
2364 
2365     if (!IsDynamic() && m_dynamic_value == NULL)
2366     {
2367         CalculateDynamicValue(use_dynamic);
2368     }
2369     if (m_dynamic_value)
2370         return m_dynamic_value->GetSP();
2371     else
2372         return ValueObjectSP();
2373 }
2374 
2375 ValueObjectSP
2376 ValueObject::GetStaticValue()
2377 {
2378     return GetSP();
2379 }
2380 
2381 lldb::ValueObjectSP
2382 ValueObject::GetNonSyntheticValue ()
2383 {
2384     return GetSP();
2385 }
2386 
2387 ValueObjectSP
2388 ValueObject::GetSyntheticValue (bool use_synthetic)
2389 {
2390     if (use_synthetic == false)
2391         return ValueObjectSP();
2392 
2393     CalculateSyntheticValue(use_synthetic);
2394 
2395     if (m_synthetic_value)
2396         return m_synthetic_value->GetSP();
2397     else
2398         return ValueObjectSP();
2399 }
2400 
2401 bool
2402 ValueObject::HasSyntheticValue()
2403 {
2404     UpdateFormatsIfNeeded();
2405 
2406     if (m_synthetic_children_sp.get() == NULL)
2407         return false;
2408 
2409     CalculateSyntheticValue(true);
2410 
2411     if (m_synthetic_value)
2412         return true;
2413     else
2414         return false;
2415 }
2416 
2417 bool
2418 ValueObject::GetBaseClassPath (Stream &s)
2419 {
2420     if (IsBaseClass())
2421     {
2422         bool parent_had_base_class = GetParent() && GetParent()->GetBaseClassPath (s);
2423         ClangASTType clang_type = GetClangType();
2424         std::string cxx_class_name;
2425         bool this_had_base_class = clang_type.GetCXXClassName (cxx_class_name);
2426         if (this_had_base_class)
2427         {
2428             if (parent_had_base_class)
2429                 s.PutCString("::");
2430             s.PutCString(cxx_class_name.c_str());
2431         }
2432         return parent_had_base_class || this_had_base_class;
2433     }
2434     return false;
2435 }
2436 
2437 
2438 ValueObject *
2439 ValueObject::GetNonBaseClassParent()
2440 {
2441     if (GetParent())
2442     {
2443         if (GetParent()->IsBaseClass())
2444             return GetParent()->GetNonBaseClassParent();
2445         else
2446             return GetParent();
2447     }
2448     return NULL;
2449 }
2450 
2451 
2452 bool
2453 ValueObject::IsBaseClass (uint32_t& depth)
2454 {
2455     if (!IsBaseClass())
2456     {
2457         depth = 0;
2458         return false;
2459     }
2460     if (GetParent())
2461     {
2462         GetParent()->IsBaseClass(depth);
2463         depth = depth + 1;
2464         return true;
2465     }
2466     // TODO: a base of no parent? weird..
2467     depth = 1;
2468     return true;
2469 }
2470 
2471 void
2472 ValueObject::GetExpressionPath (Stream &s, bool qualify_cxx_base_classes, GetExpressionPathFormat epformat)
2473 {
2474     // synthetic children do not actually "exist" as part of the hierarchy, and sometimes they are consed up in ways
2475     // that don't make sense from an underlying language/API standpoint. So, use a special code path here to return
2476     // something that can hopefully be used in expression
2477     if (m_is_synthetic_children_generated)
2478     {
2479         UpdateValueIfNeeded();
2480 
2481         if (m_value.GetValueType() == Value::eValueTypeLoadAddress)
2482         {
2483             if (IsPointerOrReferenceType())
2484             {
2485                 s.Printf("((%s)0x%" PRIx64 ")",
2486                          GetTypeName().AsCString("void"),
2487                          GetValueAsUnsigned(0));
2488                 return;
2489             }
2490             else
2491             {
2492                 uint64_t load_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
2493                 if (load_addr != LLDB_INVALID_ADDRESS)
2494                 {
2495                     s.Printf("(*( (%s *)0x%" PRIx64 "))",
2496                              GetTypeName().AsCString("void"),
2497                              load_addr);
2498                     return;
2499                 }
2500             }
2501         }
2502 
2503         if (CanProvideValue())
2504         {
2505             s.Printf("((%s)%s)",
2506                      GetTypeName().AsCString("void"),
2507                      GetValueAsCString());
2508             return;
2509         }
2510 
2511         return;
2512     }
2513 
2514     const bool is_deref_of_parent = IsDereferenceOfParent ();
2515 
2516     if (is_deref_of_parent && epformat == eGetExpressionPathFormatDereferencePointers)
2517     {
2518         // this is the original format of GetExpressionPath() producing code like *(a_ptr).memberName, which is entirely
2519         // fine, until you put this into StackFrame::GetValueForVariableExpressionPath() which prefers to see a_ptr->memberName.
2520         // the eHonorPointers mode is meant to produce strings in this latter format
2521         s.PutCString("*(");
2522     }
2523 
2524     ValueObject* parent = GetParent();
2525 
2526     if (parent)
2527         parent->GetExpressionPath (s, qualify_cxx_base_classes, epformat);
2528 
2529     // if we are a deref_of_parent just because we are synthetic array
2530     // members made up to allow ptr[%d] syntax to work in variable
2531     // printing, then add our name ([%d]) to the expression path
2532     if (m_is_array_item_for_pointer && epformat == eGetExpressionPathFormatHonorPointers)
2533         s.PutCString(m_name.AsCString());
2534 
2535     if (!IsBaseClass())
2536     {
2537         if (!is_deref_of_parent)
2538         {
2539             ValueObject *non_base_class_parent = GetNonBaseClassParent();
2540             if (non_base_class_parent)
2541             {
2542                 ClangASTType non_base_class_parent_clang_type = non_base_class_parent->GetClangType();
2543                 if (non_base_class_parent_clang_type)
2544                 {
2545                     if (parent && parent->IsDereferenceOfParent() && epformat == eGetExpressionPathFormatHonorPointers)
2546                     {
2547                         s.PutCString("->");
2548                     }
2549                     else
2550                     {
2551                         const uint32_t non_base_class_parent_type_info = non_base_class_parent_clang_type.GetTypeInfo();
2552 
2553                         if (non_base_class_parent_type_info & eTypeIsPointer)
2554                         {
2555                             s.PutCString("->");
2556                         }
2557                         else if ((non_base_class_parent_type_info & eTypeHasChildren) &&
2558                                  !(non_base_class_parent_type_info & eTypeIsArray))
2559                         {
2560                             s.PutChar('.');
2561                         }
2562                     }
2563                 }
2564             }
2565 
2566             const char *name = GetName().GetCString();
2567             if (name)
2568             {
2569                 if (qualify_cxx_base_classes)
2570                 {
2571                     if (GetBaseClassPath (s))
2572                         s.PutCString("::");
2573                 }
2574                 s.PutCString(name);
2575             }
2576         }
2577     }
2578 
2579     if (is_deref_of_parent && epformat == eGetExpressionPathFormatDereferencePointers)
2580     {
2581         s.PutChar(')');
2582     }
2583 }
2584 
2585 ValueObjectSP
2586 ValueObject::GetValueForExpressionPath(const char* expression,
2587                                        const char** first_unparsed,
2588                                        ExpressionPathScanEndReason* reason_to_stop,
2589                                        ExpressionPathEndResultType* final_value_type,
2590                                        const GetValueForExpressionPathOptions& options,
2591                                        ExpressionPathAftermath* final_task_on_target)
2592 {
2593 
2594     const char* dummy_first_unparsed;
2595     ExpressionPathScanEndReason dummy_reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnknown;
2596     ExpressionPathEndResultType dummy_final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2597     ExpressionPathAftermath dummy_final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2598 
2599     ValueObjectSP ret_val = GetValueForExpressionPath_Impl(expression,
2600                                                            first_unparsed ? first_unparsed : &dummy_first_unparsed,
2601                                                            reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2602                                                            final_value_type ? final_value_type : &dummy_final_value_type,
2603                                                            options,
2604                                                            final_task_on_target ? final_task_on_target : &dummy_final_task_on_target);
2605 
2606     if (!final_task_on_target || *final_task_on_target == ValueObject::eExpressionPathAftermathNothing)
2607         return ret_val;
2608 
2609     if (ret_val.get() && ((final_value_type ? *final_value_type : dummy_final_value_type) == eExpressionPathEndResultTypePlain)) // I can only deref and takeaddress of plain objects
2610     {
2611         if ( (final_task_on_target ? *final_task_on_target : dummy_final_task_on_target) == ValueObject::eExpressionPathAftermathDereference)
2612         {
2613             Error error;
2614             ValueObjectSP final_value = ret_val->Dereference(error);
2615             if (error.Fail() || !final_value.get())
2616             {
2617                 if (reason_to_stop)
2618                     *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2619                 if (final_value_type)
2620                     *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2621                 return ValueObjectSP();
2622             }
2623             else
2624             {
2625                 if (final_task_on_target)
2626                     *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2627                 return final_value;
2628             }
2629         }
2630         if (*final_task_on_target == ValueObject::eExpressionPathAftermathTakeAddress)
2631         {
2632             Error error;
2633             ValueObjectSP final_value = ret_val->AddressOf(error);
2634             if (error.Fail() || !final_value.get())
2635             {
2636                 if (reason_to_stop)
2637                     *reason_to_stop = ValueObject::eExpressionPathScanEndReasonTakingAddressFailed;
2638                 if (final_value_type)
2639                     *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2640                 return ValueObjectSP();
2641             }
2642             else
2643             {
2644                 if (final_task_on_target)
2645                     *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2646                 return final_value;
2647             }
2648         }
2649     }
2650     return ret_val; // final_task_on_target will still have its original value, so you know I did not do it
2651 }
2652 
2653 int
2654 ValueObject::GetValuesForExpressionPath(const char* expression,
2655                                         ValueObjectListSP& list,
2656                                         const char** first_unparsed,
2657                                         ExpressionPathScanEndReason* reason_to_stop,
2658                                         ExpressionPathEndResultType* final_value_type,
2659                                         const GetValueForExpressionPathOptions& options,
2660                                         ExpressionPathAftermath* final_task_on_target)
2661 {
2662     const char* dummy_first_unparsed;
2663     ExpressionPathScanEndReason dummy_reason_to_stop;
2664     ExpressionPathEndResultType dummy_final_value_type;
2665     ExpressionPathAftermath dummy_final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2666 
2667     ValueObjectSP ret_val = GetValueForExpressionPath_Impl(expression,
2668                                                            first_unparsed ? first_unparsed : &dummy_first_unparsed,
2669                                                            reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2670                                                            final_value_type ? final_value_type : &dummy_final_value_type,
2671                                                            options,
2672                                                            final_task_on_target ? final_task_on_target : &dummy_final_task_on_target);
2673 
2674     if (!ret_val.get()) // if there are errors, I add nothing to the list
2675         return 0;
2676 
2677     if ( (reason_to_stop ? *reason_to_stop : dummy_reason_to_stop) != eExpressionPathScanEndReasonArrayRangeOperatorMet)
2678     {
2679         // I need not expand a range, just post-process the final value and return
2680         if (!final_task_on_target || *final_task_on_target == ValueObject::eExpressionPathAftermathNothing)
2681         {
2682             list->Append(ret_val);
2683             return 1;
2684         }
2685         if (ret_val.get() && (final_value_type ? *final_value_type : dummy_final_value_type) == eExpressionPathEndResultTypePlain) // I can only deref and takeaddress of plain objects
2686         {
2687             if (*final_task_on_target == ValueObject::eExpressionPathAftermathDereference)
2688             {
2689                 Error error;
2690                 ValueObjectSP final_value = ret_val->Dereference(error);
2691                 if (error.Fail() || !final_value.get())
2692                 {
2693                     if (reason_to_stop)
2694                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2695                     if (final_value_type)
2696                         *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2697                     return 0;
2698                 }
2699                 else
2700                 {
2701                     *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2702                     list->Append(final_value);
2703                     return 1;
2704                 }
2705             }
2706             if (*final_task_on_target == ValueObject::eExpressionPathAftermathTakeAddress)
2707             {
2708                 Error error;
2709                 ValueObjectSP final_value = ret_val->AddressOf(error);
2710                 if (error.Fail() || !final_value.get())
2711                 {
2712                     if (reason_to_stop)
2713                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonTakingAddressFailed;
2714                     if (final_value_type)
2715                         *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2716                     return 0;
2717                 }
2718                 else
2719                 {
2720                     *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2721                     list->Append(final_value);
2722                     return 1;
2723                 }
2724             }
2725         }
2726     }
2727     else
2728     {
2729         return ExpandArraySliceExpression(first_unparsed ? *first_unparsed : dummy_first_unparsed,
2730                                           first_unparsed ? first_unparsed : &dummy_first_unparsed,
2731                                           ret_val,
2732                                           list,
2733                                           reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2734                                           final_value_type ? final_value_type : &dummy_final_value_type,
2735                                           options,
2736                                           final_task_on_target ? final_task_on_target : &dummy_final_task_on_target);
2737     }
2738     // in any non-covered case, just do the obviously right thing
2739     list->Append(ret_val);
2740     return 1;
2741 }
2742 
2743 ValueObjectSP
2744 ValueObject::GetValueForExpressionPath_Impl(const char* expression_cstr,
2745                                             const char** first_unparsed,
2746                                             ExpressionPathScanEndReason* reason_to_stop,
2747                                             ExpressionPathEndResultType* final_result,
2748                                             const GetValueForExpressionPathOptions& options,
2749                                             ExpressionPathAftermath* what_next)
2750 {
2751     ValueObjectSP root = GetSP();
2752 
2753     if (!root.get())
2754         return ValueObjectSP();
2755 
2756     *first_unparsed = expression_cstr;
2757 
2758     while (true)
2759     {
2760 
2761         const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
2762 
2763         ClangASTType root_clang_type = root->GetClangType();
2764         ClangASTType pointee_clang_type;
2765         Flags pointee_clang_type_info;
2766 
2767         Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type));
2768         if (pointee_clang_type)
2769             pointee_clang_type_info.Reset(pointee_clang_type.GetTypeInfo());
2770 
2771         if (!expression_cstr || *expression_cstr == '\0')
2772         {
2773             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
2774             return root;
2775         }
2776 
2777         switch (*expression_cstr)
2778         {
2779             case '-':
2780             {
2781                 if (options.m_check_dot_vs_arrow_syntax &&
2782                     root_clang_type_info.Test(eTypeIsPointer) ) // if you are trying to use -> on a non-pointer and I must catch the error
2783                 {
2784                     *first_unparsed = expression_cstr;
2785                     *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrowInsteadOfDot;
2786                     *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2787                     return ValueObjectSP();
2788                 }
2789                 if (root_clang_type_info.Test(eTypeIsObjC) &&  // if yo are trying to extract an ObjC IVar when this is forbidden
2790                     root_clang_type_info.Test(eTypeIsPointer) &&
2791                     options.m_no_fragile_ivar)
2792                 {
2793                     *first_unparsed = expression_cstr;
2794                     *reason_to_stop = ValueObject::eExpressionPathScanEndReasonFragileIVarNotAllowed;
2795                     *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2796                     return ValueObjectSP();
2797                 }
2798                 if (expression_cstr[1] != '>')
2799                 {
2800                     *first_unparsed = expression_cstr;
2801                     *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2802                     *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2803                     return ValueObjectSP();
2804                 }
2805                 expression_cstr++; // skip the -
2806             }
2807             case '.': // or fallthrough from ->
2808             {
2809                 if (options.m_check_dot_vs_arrow_syntax && *expression_cstr == '.' &&
2810                     root_clang_type_info.Test(eTypeIsPointer)) // if you are trying to use . on a pointer and I must catch the error
2811                 {
2812                     *first_unparsed = expression_cstr;
2813                     *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDotInsteadOfArrow;
2814                     *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2815                     return ValueObjectSP();
2816                 }
2817                 expression_cstr++; // skip .
2818                 const char *next_separator = strpbrk(expression_cstr+1,"-.[");
2819                 ConstString child_name;
2820                 if (!next_separator) // if no other separator just expand this last layer
2821                 {
2822                     child_name.SetCString (expression_cstr);
2823                     ValueObjectSP child_valobj_sp = root->GetChildMemberWithName(child_name, true);
2824 
2825                     if (child_valobj_sp.get()) // we know we are done, so just return
2826                     {
2827                         *first_unparsed = "";
2828                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
2829                         *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2830                         return child_valobj_sp;
2831                     }
2832                     else
2833                     {
2834                         switch (options.m_synthetic_children_traversal)
2835                         {
2836                             case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None:
2837                                 break;
2838                             case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::FromSynthetic:
2839                                 if (root->IsSynthetic())
2840                                 {
2841                                     child_valobj_sp = root->GetNonSyntheticValue();
2842                                     if (child_valobj_sp.get())
2843                                         child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2844                                 }
2845                                 break;
2846                             case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::ToSynthetic:
2847                                 if (!root->IsSynthetic())
2848                                 {
2849                                     child_valobj_sp = root->GetSyntheticValue();
2850                                     if (child_valobj_sp.get())
2851                                         child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2852                                 }
2853                                 break;
2854                             case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::Both:
2855                                 if (root->IsSynthetic())
2856                                 {
2857                                     child_valobj_sp = root->GetNonSyntheticValue();
2858                                     if (child_valobj_sp.get())
2859                                         child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2860                                 }
2861                                 else
2862                                 {
2863                                     child_valobj_sp = root->GetSyntheticValue();
2864                                     if (child_valobj_sp.get())
2865                                         child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2866                                 }
2867                                 break;
2868                         }
2869                     }
2870 
2871                     // if we are here and options.m_no_synthetic_children is true, child_valobj_sp is going to be a NULL SP,
2872                     // so we hit the "else" branch, and return an error
2873                     if(child_valobj_sp.get()) // if it worked, just return
2874                     {
2875                         *first_unparsed = "";
2876                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
2877                         *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2878                         return child_valobj_sp;
2879                     }
2880                     else
2881                     {
2882                         *first_unparsed = expression_cstr;
2883                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2884                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2885                         return ValueObjectSP();
2886                     }
2887                 }
2888                 else // other layers do expand
2889                 {
2890                     child_name.SetCStringWithLength(expression_cstr, next_separator - expression_cstr);
2891                     ValueObjectSP child_valobj_sp = root->GetChildMemberWithName(child_name, true);
2892                     if (child_valobj_sp.get()) // store the new root and move on
2893                     {
2894                         root = child_valobj_sp;
2895                         *first_unparsed = next_separator;
2896                         *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2897                         continue;
2898                     }
2899                     else
2900                     {
2901                         switch (options.m_synthetic_children_traversal)
2902                         {
2903                             case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None:
2904                                 break;
2905                             case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::FromSynthetic:
2906                                 if (root->IsSynthetic())
2907                                 {
2908                                     child_valobj_sp = root->GetNonSyntheticValue();
2909                                     if (child_valobj_sp.get())
2910                                         child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2911                                 }
2912                                 break;
2913                             case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::ToSynthetic:
2914                                 if (!root->IsSynthetic())
2915                                 {
2916                                     child_valobj_sp = root->GetSyntheticValue();
2917                                     if (child_valobj_sp.get())
2918                                         child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2919                                 }
2920                                 break;
2921                             case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::Both:
2922                                 if (root->IsSynthetic())
2923                                 {
2924                                     child_valobj_sp = root->GetNonSyntheticValue();
2925                                     if (child_valobj_sp.get())
2926                                         child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2927                                 }
2928                                 else
2929                                 {
2930                                     child_valobj_sp = root->GetSyntheticValue();
2931                                     if (child_valobj_sp.get())
2932                                         child_valobj_sp = child_valobj_sp->GetChildMemberWithName(child_name, true);
2933                                 }
2934                                 break;
2935                         }
2936                     }
2937 
2938                     // if we are here and options.m_no_synthetic_children is true, child_valobj_sp is going to be a NULL SP,
2939                     // so we hit the "else" branch, and return an error
2940                     if(child_valobj_sp.get()) // if it worked, move on
2941                     {
2942                         root = child_valobj_sp;
2943                         *first_unparsed = next_separator;
2944                         *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2945                         continue;
2946                     }
2947                     else
2948                     {
2949                         *first_unparsed = expression_cstr;
2950                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2951                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2952                         return ValueObjectSP();
2953                     }
2954                 }
2955                 break;
2956             }
2957             case '[':
2958             {
2959                 if (!root_clang_type_info.Test(eTypeIsArray) && !root_clang_type_info.Test(eTypeIsPointer) && !root_clang_type_info.Test(eTypeIsVector)) // if this is not a T[] nor a T*
2960                 {
2961                     if (!root_clang_type_info.Test(eTypeIsScalar)) // if this is not even a scalar...
2962                     {
2963                         if (options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::None) // ...only chance left is synthetic
2964                         {
2965                             *first_unparsed = expression_cstr;
2966                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid;
2967                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2968                             return ValueObjectSP();
2969                         }
2970                     }
2971                     else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields
2972                     {
2973                         *first_unparsed = expression_cstr;
2974                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed;
2975                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2976                         return ValueObjectSP();
2977                     }
2978                 }
2979                 if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays
2980                 {
2981                     if (!root_clang_type_info.Test(eTypeIsArray))
2982                     {
2983                         *first_unparsed = expression_cstr;
2984                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
2985                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2986                         return ValueObjectSP();
2987                     }
2988                     else // even if something follows, we cannot expand unbounded ranges, just let the caller do it
2989                     {
2990                         *first_unparsed = expression_cstr+2;
2991                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
2992                         *final_result = ValueObject::eExpressionPathEndResultTypeUnboundedRange;
2993                         return root;
2994                     }
2995                 }
2996                 const char *separator_position = ::strchr(expression_cstr+1,'-');
2997                 const char *close_bracket_position = ::strchr(expression_cstr+1,']');
2998                 if (!close_bracket_position) // if there is no ], this is a syntax error
2999                 {
3000                     *first_unparsed = expression_cstr;
3001                     *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3002                     *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3003                     return ValueObjectSP();
3004                 }
3005                 if (!separator_position || separator_position > close_bracket_position) // if no separator, this is either [] or [N]
3006                 {
3007                     char *end = NULL;
3008                     unsigned long index = ::strtoul (expression_cstr+1, &end, 0);
3009                     if (!end || end != close_bracket_position) // if something weird is in our way return an error
3010                     {
3011                         *first_unparsed = expression_cstr;
3012                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3013                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3014                         return ValueObjectSP();
3015                     }
3016                     if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays
3017                     {
3018                         if (root_clang_type_info.Test(eTypeIsArray))
3019                         {
3020                             *first_unparsed = expression_cstr+2;
3021                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
3022                             *final_result = ValueObject::eExpressionPathEndResultTypeUnboundedRange;
3023                             return root;
3024                         }
3025                         else
3026                         {
3027                             *first_unparsed = expression_cstr;
3028                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
3029                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3030                             return ValueObjectSP();
3031                         }
3032                     }
3033                     // from here on we do have a valid index
3034                     if (root_clang_type_info.Test(eTypeIsArray))
3035                     {
3036                         ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index, true);
3037                         if (!child_valobj_sp)
3038                             child_valobj_sp = root->GetSyntheticArrayMember(index, true);
3039                         if (!child_valobj_sp)
3040                             if (root->HasSyntheticValue() && root->GetSyntheticValue()->GetNumChildren() > index)
3041                                 child_valobj_sp = root->GetSyntheticValue()->GetChildAtIndex(index, true);
3042                         if (child_valobj_sp)
3043                         {
3044                             root = child_valobj_sp;
3045                             *first_unparsed = end+1; // skip ]
3046                             *final_result = ValueObject::eExpressionPathEndResultTypePlain;
3047                             continue;
3048                         }
3049                         else
3050                         {
3051                             *first_unparsed = expression_cstr;
3052                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3053                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3054                             return ValueObjectSP();
3055                         }
3056                     }
3057                     else if (root_clang_type_info.Test(eTypeIsPointer))
3058                     {
3059                         if (*what_next == ValueObject::eExpressionPathAftermathDereference &&  // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
3060                             pointee_clang_type_info.Test(eTypeIsScalar))
3061                         {
3062                             Error error;
3063                             root = root->Dereference(error);
3064                             if (error.Fail() || !root.get())
3065                             {
3066                                 *first_unparsed = expression_cstr;
3067                                 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
3068                                 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3069                                 return ValueObjectSP();
3070                             }
3071                             else
3072                             {
3073                                 *what_next = eExpressionPathAftermathNothing;
3074                                 continue;
3075                             }
3076                         }
3077                         else
3078                         {
3079                             if (root->GetClangType().GetMinimumLanguage() == eLanguageTypeObjC
3080                                 && pointee_clang_type_info.AllClear(eTypeIsPointer)
3081                                 && root->HasSyntheticValue()
3082                                 && (options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::ToSynthetic ||
3083                                     options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::Both))
3084                             {
3085                                 root = root->GetSyntheticValue()->GetChildAtIndex(index, true);
3086                             }
3087                             else
3088                                 root = root->GetSyntheticArrayMember(index, true);
3089                             if (!root.get())
3090                             {
3091                                 *first_unparsed = expression_cstr;
3092                                 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3093                                 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3094                                 return ValueObjectSP();
3095                             }
3096                             else
3097                             {
3098                                 *first_unparsed = end+1; // skip ]
3099                                 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
3100                                 continue;
3101                             }
3102                         }
3103                     }
3104                     else if (root_clang_type_info.Test(eTypeIsScalar))
3105                     {
3106                         root = root->GetSyntheticBitFieldChild(index, index, true);
3107                         if (!root.get())
3108                         {
3109                             *first_unparsed = expression_cstr;
3110                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3111                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3112                             return ValueObjectSP();
3113                         }
3114                         else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing
3115                         {
3116                             *first_unparsed = end+1; // skip ]
3117                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
3118                             *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
3119                             return root;
3120                         }
3121                     }
3122                     else if (root_clang_type_info.Test(eTypeIsVector))
3123                     {
3124                         root = root->GetChildAtIndex(index, true);
3125                         if (!root.get())
3126                         {
3127                             *first_unparsed = expression_cstr;
3128                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3129                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3130                             return ValueObjectSP();
3131                         }
3132                         else
3133                         {
3134                             *first_unparsed = end+1; // skip ]
3135                             *final_result = ValueObject::eExpressionPathEndResultTypePlain;
3136                             continue;
3137                         }
3138                     }
3139                     else if (options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::ToSynthetic ||
3140                              options.m_synthetic_children_traversal == GetValueForExpressionPathOptions::SyntheticChildrenTraversal::Both)
3141                     {
3142                         if (root->HasSyntheticValue())
3143                             root = root->GetSyntheticValue();
3144                         else if (!root->IsSynthetic())
3145                         {
3146                             *first_unparsed = expression_cstr;
3147                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonSyntheticValueMissing;
3148                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3149                             return ValueObjectSP();
3150                         }
3151                         // if we are here, then root itself is a synthetic VO.. should be good to go
3152 
3153                         if (!root.get())
3154                         {
3155                             *first_unparsed = expression_cstr;
3156                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonSyntheticValueMissing;
3157                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3158                             return ValueObjectSP();
3159                         }
3160                         root = root->GetChildAtIndex(index, true);
3161                         if (!root.get())
3162                         {
3163                             *first_unparsed = expression_cstr;
3164                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3165                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3166                             return ValueObjectSP();
3167                         }
3168                         else
3169                         {
3170                             *first_unparsed = end+1; // skip ]
3171                             *final_result = ValueObject::eExpressionPathEndResultTypePlain;
3172                             continue;
3173                         }
3174                     }
3175                     else
3176                     {
3177                         *first_unparsed = expression_cstr;
3178                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3179                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3180                         return ValueObjectSP();
3181                     }
3182                 }
3183                 else // we have a low and a high index
3184                 {
3185                     char *end = NULL;
3186                     unsigned long index_lower = ::strtoul (expression_cstr+1, &end, 0);
3187                     if (!end || end != separator_position) // if something weird is in our way return an error
3188                     {
3189                         *first_unparsed = expression_cstr;
3190                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3191                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3192                         return ValueObjectSP();
3193                     }
3194                     unsigned long index_higher = ::strtoul (separator_position+1, &end, 0);
3195                     if (!end || end != close_bracket_position) // if something weird is in our way return an error
3196                     {
3197                         *first_unparsed = expression_cstr;
3198                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3199                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3200                         return ValueObjectSP();
3201                     }
3202                     if (index_lower > index_higher) // swap indices if required
3203                     {
3204                         unsigned long temp = index_lower;
3205                         index_lower = index_higher;
3206                         index_higher = temp;
3207                     }
3208                     if (root_clang_type_info.Test(eTypeIsScalar)) // expansion only works for scalars
3209                     {
3210                         root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true);
3211                         if (!root.get())
3212                         {
3213                             *first_unparsed = expression_cstr;
3214                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3215                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3216                             return ValueObjectSP();
3217                         }
3218                         else
3219                         {
3220                             *first_unparsed = end+1; // skip ]
3221                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
3222                             *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
3223                             return root;
3224                         }
3225                     }
3226                     else if (root_clang_type_info.Test(eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
3227                              *what_next == ValueObject::eExpressionPathAftermathDereference &&
3228                              pointee_clang_type_info.Test(eTypeIsScalar))
3229                     {
3230                         Error error;
3231                         root = root->Dereference(error);
3232                         if (error.Fail() || !root.get())
3233                         {
3234                             *first_unparsed = expression_cstr;
3235                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
3236                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3237                             return ValueObjectSP();
3238                         }
3239                         else
3240                         {
3241                             *what_next = ValueObject::eExpressionPathAftermathNothing;
3242                             continue;
3243                         }
3244                     }
3245                     else
3246                     {
3247                         *first_unparsed = expression_cstr;
3248                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
3249                         *final_result = ValueObject::eExpressionPathEndResultTypeBoundedRange;
3250                         return root;
3251                     }
3252                 }
3253                 break;
3254             }
3255             default: // some non-separator is in the way
3256             {
3257                 *first_unparsed = expression_cstr;
3258                 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3259                 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3260                 return ValueObjectSP();
3261                 break;
3262             }
3263         }
3264     }
3265 }
3266 
3267 int
3268 ValueObject::ExpandArraySliceExpression(const char* expression_cstr,
3269                                         const char** first_unparsed,
3270                                         ValueObjectSP root,
3271                                         ValueObjectListSP& list,
3272                                         ExpressionPathScanEndReason* reason_to_stop,
3273                                         ExpressionPathEndResultType* final_result,
3274                                         const GetValueForExpressionPathOptions& options,
3275                                         ExpressionPathAftermath* what_next)
3276 {
3277     if (!root.get())
3278         return 0;
3279 
3280     *first_unparsed = expression_cstr;
3281 
3282     while (true)
3283     {
3284 
3285         const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
3286 
3287         ClangASTType root_clang_type = root->GetClangType();
3288         ClangASTType pointee_clang_type;
3289         Flags pointee_clang_type_info;
3290         Flags root_clang_type_info(root_clang_type.GetTypeInfo(&pointee_clang_type));
3291         if (pointee_clang_type)
3292             pointee_clang_type_info.Reset(pointee_clang_type.GetTypeInfo());
3293 
3294         if (!expression_cstr || *expression_cstr == '\0')
3295         {
3296             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
3297             list->Append(root);
3298             return 1;
3299         }
3300 
3301         switch (*expression_cstr)
3302         {
3303             case '[':
3304             {
3305                 if (!root_clang_type_info.Test(eTypeIsArray) && !root_clang_type_info.Test(eTypeIsPointer)) // if this is not a T[] nor a T*
3306                 {
3307                     if (!root_clang_type_info.Test(eTypeIsScalar)) // if this is not even a scalar, this syntax is just plain wrong!
3308                     {
3309                         *first_unparsed = expression_cstr;
3310                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid;
3311                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3312                         return 0;
3313                     }
3314                     else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields
3315                     {
3316                         *first_unparsed = expression_cstr;
3317                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed;
3318                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3319                         return 0;
3320                     }
3321                 }
3322                 if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays
3323                 {
3324                     if (!root_clang_type_info.Test(eTypeIsArray))
3325                     {
3326                         *first_unparsed = expression_cstr;
3327                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
3328                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3329                         return 0;
3330                     }
3331                     else // expand this into list
3332                     {
3333                         const size_t max_index = root->GetNumChildren() - 1;
3334                         for (size_t index = 0; index < max_index; index++)
3335                         {
3336                             ValueObjectSP child =
3337                                 root->GetChildAtIndex(index, true);
3338                             list->Append(child);
3339                         }
3340                         *first_unparsed = expression_cstr+2;
3341                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3342                         *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3343                         return max_index; // tell me number of items I added to the VOList
3344                     }
3345                 }
3346                 const char *separator_position = ::strchr(expression_cstr+1,'-');
3347                 const char *close_bracket_position = ::strchr(expression_cstr+1,']');
3348                 if (!close_bracket_position) // if there is no ], this is a syntax error
3349                 {
3350                     *first_unparsed = expression_cstr;
3351                     *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3352                     *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3353                     return 0;
3354                 }
3355                 if (!separator_position || separator_position > close_bracket_position) // if no separator, this is either [] or [N]
3356                 {
3357                     char *end = NULL;
3358                     unsigned long index = ::strtoul (expression_cstr+1, &end, 0);
3359                     if (!end || end != close_bracket_position) // if something weird is in our way return an error
3360                     {
3361                         *first_unparsed = expression_cstr;
3362                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3363                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3364                         return 0;
3365                     }
3366                     if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays
3367                     {
3368                         if (root_clang_type_info.Test(eTypeIsArray))
3369                         {
3370                             const size_t max_index = root->GetNumChildren() - 1;
3371                             for (size_t index = 0; index < max_index; index++)
3372                             {
3373                                 ValueObjectSP child =
3374                                 root->GetChildAtIndex(index, true);
3375                                 list->Append(child);
3376                             }
3377                             *first_unparsed = expression_cstr+2;
3378                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3379                             *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3380                             return max_index; // tell me number of items I added to the VOList
3381                         }
3382                         else
3383                         {
3384                             *first_unparsed = expression_cstr;
3385                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
3386                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3387                             return 0;
3388                         }
3389                     }
3390                     // from here on we do have a valid index
3391                     if (root_clang_type_info.Test(eTypeIsArray))
3392                     {
3393                         root = root->GetChildAtIndex(index, true);
3394                         if (!root.get())
3395                         {
3396                             *first_unparsed = expression_cstr;
3397                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3398                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3399                             return 0;
3400                         }
3401                         else
3402                         {
3403                             list->Append(root);
3404                             *first_unparsed = end+1; // skip ]
3405                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3406                             *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3407                             return 1;
3408                         }
3409                     }
3410                     else if (root_clang_type_info.Test(eTypeIsPointer))
3411                     {
3412                         if (*what_next == ValueObject::eExpressionPathAftermathDereference &&  // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
3413                             pointee_clang_type_info.Test(eTypeIsScalar))
3414                         {
3415                             Error error;
3416                             root = root->Dereference(error);
3417                             if (error.Fail() || !root.get())
3418                             {
3419                                 *first_unparsed = expression_cstr;
3420                                 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
3421                                 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3422                                 return 0;
3423                             }
3424                             else
3425                             {
3426                                 *what_next = eExpressionPathAftermathNothing;
3427                                 continue;
3428                             }
3429                         }
3430                         else
3431                         {
3432                             root = root->GetSyntheticArrayMember(index, true);
3433                             if (!root.get())
3434                             {
3435                                 *first_unparsed = expression_cstr;
3436                                 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3437                                 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3438                                 return 0;
3439                             }
3440                             else
3441                             {
3442                                 list->Append(root);
3443                                 *first_unparsed = end+1; // skip ]
3444                                 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3445                                 *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3446                                 return 1;
3447                             }
3448                         }
3449                     }
3450                     else /*if (ClangASTContext::IsScalarType(root_clang_type))*/
3451                     {
3452                         root = root->GetSyntheticBitFieldChild(index, index, true);
3453                         if (!root.get())
3454                         {
3455                             *first_unparsed = expression_cstr;
3456                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3457                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3458                             return 0;
3459                         }
3460                         else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing
3461                         {
3462                             list->Append(root);
3463                             *first_unparsed = end+1; // skip ]
3464                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3465                             *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3466                             return 1;
3467                         }
3468                     }
3469                 }
3470                 else // we have a low and a high index
3471                 {
3472                     char *end = NULL;
3473                     unsigned long index_lower = ::strtoul (expression_cstr+1, &end, 0);
3474                     if (!end || end != separator_position) // if something weird is in our way return an error
3475                     {
3476                         *first_unparsed = expression_cstr;
3477                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3478                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3479                         return 0;
3480                     }
3481                     unsigned long index_higher = ::strtoul (separator_position+1, &end, 0);
3482                     if (!end || end != close_bracket_position) // if something weird is in our way return an error
3483                     {
3484                         *first_unparsed = expression_cstr;
3485                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3486                         *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3487                         return 0;
3488                     }
3489                     if (index_lower > index_higher) // swap indices if required
3490                     {
3491                         unsigned long temp = index_lower;
3492                         index_lower = index_higher;
3493                         index_higher = temp;
3494                     }
3495                     if (root_clang_type_info.Test(eTypeIsScalar)) // expansion only works for scalars
3496                     {
3497                         root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true);
3498                         if (!root.get())
3499                         {
3500                             *first_unparsed = expression_cstr;
3501                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonNoSuchChild;
3502                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3503                             return 0;
3504                         }
3505                         else
3506                         {
3507                             list->Append(root);
3508                             *first_unparsed = end+1; // skip ]
3509                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3510                             *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3511                             return 1;
3512                         }
3513                     }
3514                     else if (root_clang_type_info.Test(eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
3515                              *what_next == ValueObject::eExpressionPathAftermathDereference &&
3516                              pointee_clang_type_info.Test(eTypeIsScalar))
3517                     {
3518                         Error error;
3519                         root = root->Dereference(error);
3520                         if (error.Fail() || !root.get())
3521                         {
3522                             *first_unparsed = expression_cstr;
3523                             *reason_to_stop = ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
3524                             *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3525                             return 0;
3526                         }
3527                         else
3528                         {
3529                             *what_next = ValueObject::eExpressionPathAftermathNothing;
3530                             continue;
3531                         }
3532                     }
3533                     else
3534                     {
3535                         for (unsigned long index = index_lower;
3536                              index <= index_higher; index++)
3537                         {
3538                             ValueObjectSP child =
3539                                 root->GetChildAtIndex(index, true);
3540                             list->Append(child);
3541                         }
3542                         *first_unparsed = end+1;
3543                         *reason_to_stop = ValueObject::eExpressionPathScanEndReasonRangeOperatorExpanded;
3544                         *final_result = ValueObject::eExpressionPathEndResultTypeValueObjectList;
3545                         return index_higher-index_lower+1; // tell me number of items I added to the VOList
3546                     }
3547                 }
3548                 break;
3549             }
3550             default: // some non-[ separator, or something entirely wrong, is in the way
3551             {
3552                 *first_unparsed = expression_cstr;
3553                 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
3554                 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
3555                 return 0;
3556                 break;
3557             }
3558         }
3559     }
3560 }
3561 
3562 void
3563 ValueObject::LogValueObject (Log *log)
3564 {
3565     if (log)
3566         return LogValueObject (log, DumpValueObjectOptions::DefaultOptions());
3567 }
3568 
3569 void
3570 ValueObject::LogValueObject (Log *log, const DumpValueObjectOptions& options)
3571 {
3572     if (log)
3573     {
3574         StreamString s;
3575         Dump (s, options);
3576         if (s.GetSize())
3577             log->PutCString(s.GetData());
3578     }
3579 }
3580 
3581 void
3582 ValueObject::Dump (Stream &s)
3583 {
3584     Dump (s, DumpValueObjectOptions::DefaultOptions());
3585 }
3586 
3587 void
3588 ValueObject::Dump (Stream &s,
3589                    const DumpValueObjectOptions& options)
3590 {
3591     ValueObjectPrinter printer(this,&s,options);
3592     printer.PrintValueObject();
3593 }
3594 
3595 ValueObjectSP
3596 ValueObject::CreateConstantValue (const ConstString &name)
3597 {
3598     ValueObjectSP valobj_sp;
3599 
3600     if (UpdateValueIfNeeded(false) && m_error.Success())
3601     {
3602         ExecutionContext exe_ctx (GetExecutionContextRef());
3603 
3604         DataExtractor data;
3605         data.SetByteOrder (m_data.GetByteOrder());
3606         data.SetAddressByteSize(m_data.GetAddressByteSize());
3607 
3608         if (IsBitfield())
3609         {
3610             Value v(Scalar(GetValueAsUnsigned(UINT64_MAX)));
3611             m_error = v.GetValueAsData (&exe_ctx, data, 0, GetModule().get());
3612         }
3613         else
3614             m_error = m_value.GetValueAsData (&exe_ctx, data, 0, GetModule().get());
3615 
3616         valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
3617                                                     GetClangType(),
3618                                                     name,
3619                                                     data,
3620                                                     GetAddressOf());
3621     }
3622 
3623     if (!valobj_sp)
3624     {
3625         ExecutionContext exe_ctx (GetExecutionContextRef());
3626         valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), m_error);
3627     }
3628     return valobj_sp;
3629 }
3630 
3631 ValueObjectSP
3632 ValueObject::GetQualifiedRepresentationIfAvailable (lldb::DynamicValueType dynValue,
3633                                                     bool synthValue)
3634 {
3635     ValueObjectSP result_sp(GetSP());
3636 
3637     switch (dynValue)
3638     {
3639         case lldb::eDynamicCanRunTarget:
3640         case lldb::eDynamicDontRunTarget:
3641         {
3642             if (!result_sp->IsDynamic())
3643             {
3644                 if (result_sp->GetDynamicValue(dynValue))
3645                     result_sp = result_sp->GetDynamicValue(dynValue);
3646             }
3647         }
3648             break;
3649         case lldb::eNoDynamicValues:
3650         {
3651             if (result_sp->IsDynamic())
3652             {
3653                 if (result_sp->GetStaticValue())
3654                     result_sp = result_sp->GetStaticValue();
3655             }
3656         }
3657             break;
3658     }
3659 
3660     if (synthValue)
3661     {
3662         if (!result_sp->IsSynthetic())
3663         {
3664             if (result_sp->GetSyntheticValue())
3665                 result_sp = result_sp->GetSyntheticValue();
3666         }
3667     }
3668     else
3669     {
3670         if (result_sp->IsSynthetic())
3671         {
3672             if (result_sp->GetNonSyntheticValue())
3673                 result_sp = result_sp->GetNonSyntheticValue();
3674         }
3675     }
3676 
3677     return result_sp;
3678 }
3679 
3680 lldb::addr_t
3681 ValueObject::GetCPPVTableAddress (AddressType &address_type)
3682 {
3683     ClangASTType pointee_type;
3684     ClangASTType this_type(GetClangType());
3685     uint32_t type_info = this_type.GetTypeInfo(&pointee_type);
3686     if (type_info)
3687     {
3688         bool ptr_or_ref = false;
3689         if (type_info & (eTypeIsPointer | eTypeIsReference))
3690         {
3691             ptr_or_ref = true;
3692             type_info = pointee_type.GetTypeInfo();
3693         }
3694 
3695         const uint32_t cpp_class = eTypeIsClass | eTypeIsCPlusPlus;
3696         if ((type_info & cpp_class) == cpp_class)
3697         {
3698             if (ptr_or_ref)
3699             {
3700                 address_type = GetAddressTypeOfChildren();
3701                 return GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
3702             }
3703             else
3704                 return GetAddressOf (false, &address_type);
3705         }
3706     }
3707 
3708     address_type = eAddressTypeInvalid;
3709     return LLDB_INVALID_ADDRESS;
3710 }
3711 
3712 ValueObjectSP
3713 ValueObject::Dereference (Error &error)
3714 {
3715     if (m_deref_valobj)
3716         return m_deref_valobj->GetSP();
3717 
3718     const bool is_pointer_type = IsPointerType();
3719     if (is_pointer_type)
3720     {
3721         bool omit_empty_base_classes = true;
3722         bool ignore_array_bounds = false;
3723 
3724         std::string child_name_str;
3725         uint32_t child_byte_size = 0;
3726         int32_t child_byte_offset = 0;
3727         uint32_t child_bitfield_bit_size = 0;
3728         uint32_t child_bitfield_bit_offset = 0;
3729         bool child_is_base_class = false;
3730         bool child_is_deref_of_parent = false;
3731         const bool transparent_pointers = false;
3732         ClangASTType clang_type = GetClangType();
3733         ClangASTType child_clang_type;
3734 
3735         ExecutionContext exe_ctx (GetExecutionContextRef());
3736 
3737         child_clang_type = clang_type.GetChildClangTypeAtIndex (&exe_ctx,
3738                                                                 0,
3739                                                                 transparent_pointers,
3740                                                                 omit_empty_base_classes,
3741                                                                 ignore_array_bounds,
3742                                                                 child_name_str,
3743                                                                 child_byte_size,
3744                                                                 child_byte_offset,
3745                                                                 child_bitfield_bit_size,
3746                                                                 child_bitfield_bit_offset,
3747                                                                 child_is_base_class,
3748                                                                 child_is_deref_of_parent,
3749                                                                 this);
3750         if (child_clang_type && child_byte_size)
3751         {
3752             ConstString child_name;
3753             if (!child_name_str.empty())
3754                 child_name.SetCString (child_name_str.c_str());
3755 
3756             m_deref_valobj = new ValueObjectChild (*this,
3757                                                    child_clang_type,
3758                                                    child_name,
3759                                                    child_byte_size,
3760                                                    child_byte_offset,
3761                                                    child_bitfield_bit_size,
3762                                                    child_bitfield_bit_offset,
3763                                                    child_is_base_class,
3764                                                    child_is_deref_of_parent,
3765                                                    eAddressTypeInvalid);
3766         }
3767     }
3768 
3769     if (m_deref_valobj)
3770     {
3771         error.Clear();
3772         return m_deref_valobj->GetSP();
3773     }
3774     else
3775     {
3776         StreamString strm;
3777         GetExpressionPath(strm, true);
3778 
3779         if (is_pointer_type)
3780             error.SetErrorStringWithFormat("dereference failed: (%s) %s", GetTypeName().AsCString("<invalid type>"), strm.GetString().c_str());
3781         else
3782             error.SetErrorStringWithFormat("not a pointer type: (%s) %s", GetTypeName().AsCString("<invalid type>"), strm.GetString().c_str());
3783         return ValueObjectSP();
3784     }
3785 }
3786 
3787 ValueObjectSP
3788 ValueObject::AddressOf (Error &error)
3789 {
3790     if (m_addr_of_valobj_sp)
3791         return m_addr_of_valobj_sp;
3792 
3793     AddressType address_type = eAddressTypeInvalid;
3794     const bool scalar_is_load_address = false;
3795     addr_t addr = GetAddressOf (scalar_is_load_address, &address_type);
3796     error.Clear();
3797     if (addr != LLDB_INVALID_ADDRESS && address_type != eAddressTypeHost)
3798     {
3799         switch (address_type)
3800         {
3801         case eAddressTypeInvalid:
3802             {
3803                 StreamString expr_path_strm;
3804                 GetExpressionPath(expr_path_strm, true);
3805                 error.SetErrorStringWithFormat("'%s' is not in memory", expr_path_strm.GetString().c_str());
3806             }
3807             break;
3808 
3809         case eAddressTypeFile:
3810         case eAddressTypeLoad:
3811             {
3812                 ClangASTType clang_type = GetClangType();
3813                 if (clang_type)
3814                 {
3815                     std::string name (1, '&');
3816                     name.append (m_name.AsCString(""));
3817                     ExecutionContext exe_ctx (GetExecutionContextRef());
3818                     m_addr_of_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
3819                                                                           clang_type.GetPointerType(),
3820                                                                           ConstString (name.c_str()),
3821                                                                           addr,
3822                                                                           eAddressTypeInvalid,
3823                                                                           m_data.GetAddressByteSize());
3824                 }
3825             }
3826             break;
3827         default:
3828             break;
3829         }
3830     }
3831     else
3832     {
3833         StreamString expr_path_strm;
3834         GetExpressionPath(expr_path_strm, true);
3835         error.SetErrorStringWithFormat("'%s' doesn't have a valid address", expr_path_strm.GetString().c_str());
3836     }
3837 
3838     return m_addr_of_valobj_sp;
3839 }
3840 
3841 ValueObjectSP
3842 ValueObject::Cast (const ClangASTType &clang_ast_type)
3843 {
3844     return ValueObjectCast::Create (*this, GetName(), clang_ast_type);
3845 }
3846 
3847 ValueObjectSP
3848 ValueObject::CastPointerType (const char *name, ClangASTType &clang_ast_type)
3849 {
3850     ValueObjectSP valobj_sp;
3851     AddressType address_type;
3852     addr_t ptr_value = GetPointerValue (&address_type);
3853 
3854     if (ptr_value != LLDB_INVALID_ADDRESS)
3855     {
3856         Address ptr_addr (ptr_value);
3857         ExecutionContext exe_ctx (GetExecutionContextRef());
3858         valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(),
3859                                                name,
3860                                                ptr_addr,
3861                                                clang_ast_type);
3862     }
3863     return valobj_sp;
3864 }
3865 
3866 ValueObjectSP
3867 ValueObject::CastPointerType (const char *name, TypeSP &type_sp)
3868 {
3869     ValueObjectSP valobj_sp;
3870     AddressType address_type;
3871     addr_t ptr_value = GetPointerValue (&address_type);
3872 
3873     if (ptr_value != LLDB_INVALID_ADDRESS)
3874     {
3875         Address ptr_addr (ptr_value);
3876         ExecutionContext exe_ctx (GetExecutionContextRef());
3877         valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(),
3878                                                name,
3879                                                ptr_addr,
3880                                                type_sp);
3881     }
3882     return valobj_sp;
3883 }
3884 
3885 ValueObject::EvaluationPoint::EvaluationPoint () :
3886     m_mod_id(),
3887     m_exe_ctx_ref(),
3888     m_needs_update (true)
3889 {
3890 }
3891 
3892 ValueObject::EvaluationPoint::EvaluationPoint (ExecutionContextScope *exe_scope, bool use_selected):
3893     m_mod_id(),
3894     m_exe_ctx_ref(),
3895     m_needs_update (true)
3896 {
3897     ExecutionContext exe_ctx(exe_scope);
3898     TargetSP target_sp (exe_ctx.GetTargetSP());
3899     if (target_sp)
3900     {
3901         m_exe_ctx_ref.SetTargetSP (target_sp);
3902         ProcessSP process_sp (exe_ctx.GetProcessSP());
3903         if (!process_sp)
3904             process_sp = target_sp->GetProcessSP();
3905 
3906         if (process_sp)
3907         {
3908             m_mod_id = process_sp->GetModID();
3909             m_exe_ctx_ref.SetProcessSP (process_sp);
3910 
3911             ThreadSP thread_sp (exe_ctx.GetThreadSP());
3912 
3913             if (!thread_sp)
3914             {
3915                 if (use_selected)
3916                     thread_sp = process_sp->GetThreadList().GetSelectedThread();
3917             }
3918 
3919             if (thread_sp)
3920             {
3921                 m_exe_ctx_ref.SetThreadSP(thread_sp);
3922 
3923                 StackFrameSP frame_sp (exe_ctx.GetFrameSP());
3924                 if (!frame_sp)
3925                 {
3926                     if (use_selected)
3927                         frame_sp = thread_sp->GetSelectedFrame();
3928                 }
3929                 if (frame_sp)
3930                     m_exe_ctx_ref.SetFrameSP(frame_sp);
3931             }
3932         }
3933     }
3934 }
3935 
3936 ValueObject::EvaluationPoint::EvaluationPoint (const ValueObject::EvaluationPoint &rhs) :
3937     m_mod_id(),
3938     m_exe_ctx_ref(rhs.m_exe_ctx_ref),
3939     m_needs_update (true)
3940 {
3941 }
3942 
3943 ValueObject::EvaluationPoint::~EvaluationPoint ()
3944 {
3945 }
3946 
3947 // This function checks the EvaluationPoint against the current process state.  If the current
3948 // state matches the evaluation point, or the evaluation point is already invalid, then we return
3949 // false, meaning "no change".  If the current state is different, we update our state, and return
3950 // true meaning "yes, change".  If we did see a change, we also set m_needs_update to true, so
3951 // future calls to NeedsUpdate will return true.
3952 // exe_scope will be set to the current execution context scope.
3953 
3954 bool
3955 ValueObject::EvaluationPoint::SyncWithProcessState(bool accept_invalid_exe_ctx)
3956 {
3957     // Start with the target, if it is NULL, then we're obviously not going to get any further:
3958     const bool thread_and_frame_only_if_stopped = true;
3959     ExecutionContext exe_ctx(m_exe_ctx_ref.Lock(thread_and_frame_only_if_stopped));
3960 
3961     if (exe_ctx.GetTargetPtr() == NULL)
3962         return false;
3963 
3964     // If we don't have a process nothing can change.
3965     Process *process = exe_ctx.GetProcessPtr();
3966     if (process == NULL)
3967         return false;
3968 
3969     // If our stop id is the current stop ID, nothing has changed:
3970     ProcessModID current_mod_id = process->GetModID();
3971 
3972     // If the current stop id is 0, either we haven't run yet, or the process state has been cleared.
3973     // In either case, we aren't going to be able to sync with the process state.
3974     if (current_mod_id.GetStopID() == 0)
3975         return false;
3976 
3977     bool changed = false;
3978     const bool was_valid = m_mod_id.IsValid();
3979     if (was_valid)
3980     {
3981         if (m_mod_id == current_mod_id)
3982         {
3983             // Everything is already up to date in this object, no need to
3984             // update the execution context scope.
3985             changed = false;
3986         }
3987         else
3988         {
3989             m_mod_id = current_mod_id;
3990             m_needs_update = true;
3991             changed = true;
3992         }
3993     }
3994 
3995     // Now re-look up the thread and frame in case the underlying objects have gone away & been recreated.
3996     // That way we'll be sure to return a valid exe_scope.
3997     // If we used to have a thread or a frame but can't find it anymore, then mark ourselves as invalid.
3998 
3999     if (!accept_invalid_exe_ctx)
4000     {
4001         if (m_exe_ctx_ref.HasThreadRef())
4002         {
4003             ThreadSP thread_sp (m_exe_ctx_ref.GetThreadSP());
4004             if (thread_sp)
4005             {
4006                 if (m_exe_ctx_ref.HasFrameRef())
4007                 {
4008                     StackFrameSP frame_sp (m_exe_ctx_ref.GetFrameSP());
4009                     if (!frame_sp)
4010                     {
4011                         // We used to have a frame, but now it is gone
4012                         SetInvalid();
4013                         changed = was_valid;
4014                     }
4015                 }
4016             }
4017             else
4018             {
4019                 // We used to have a thread, but now it is gone
4020                 SetInvalid();
4021                 changed = was_valid;
4022             }
4023         }
4024     }
4025 
4026     return changed;
4027 }
4028 
4029 void
4030 ValueObject::EvaluationPoint::SetUpdated ()
4031 {
4032     ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
4033     if (process_sp)
4034         m_mod_id = process_sp->GetModID();
4035     m_needs_update = false;
4036 }
4037 
4038 
4039 
4040 void
4041 ValueObject::ClearUserVisibleData(uint32_t clear_mask)
4042 {
4043     if ((clear_mask & eClearUserVisibleDataItemsValue) == eClearUserVisibleDataItemsValue)
4044         m_value_str.clear();
4045 
4046     if ((clear_mask & eClearUserVisibleDataItemsLocation) == eClearUserVisibleDataItemsLocation)
4047         m_location_str.clear();
4048 
4049     if ((clear_mask & eClearUserVisibleDataItemsSummary) == eClearUserVisibleDataItemsSummary)
4050         m_summary_str.clear();
4051 
4052     if ((clear_mask & eClearUserVisibleDataItemsDescription) == eClearUserVisibleDataItemsDescription)
4053         m_object_desc_str.clear();
4054 
4055     if ((clear_mask & eClearUserVisibleDataItemsSyntheticChildren) == eClearUserVisibleDataItemsSyntheticChildren)
4056     {
4057             if (m_synthetic_value)
4058                 m_synthetic_value = NULL;
4059     }
4060 
4061     if ((clear_mask & eClearUserVisibleDataItemsValidator) == eClearUserVisibleDataItemsValidator)
4062         m_validation_result.reset();
4063 }
4064 
4065 SymbolContextScope *
4066 ValueObject::GetSymbolContextScope()
4067 {
4068     if (m_parent)
4069     {
4070         if (!m_parent->IsPointerOrReferenceType())
4071             return m_parent->GetSymbolContextScope();
4072     }
4073     return NULL;
4074 }
4075 
4076 lldb::ValueObjectSP
4077 ValueObject::CreateValueObjectFromExpression (const char* name,
4078                                               const char* expression,
4079                                               const ExecutionContext& exe_ctx)
4080 {
4081     return CreateValueObjectFromExpression(name, expression, exe_ctx, EvaluateExpressionOptions());
4082 }
4083 
4084 
4085 lldb::ValueObjectSP
4086 ValueObject::CreateValueObjectFromExpression (const char* name,
4087                                               const char* expression,
4088                                               const ExecutionContext& exe_ctx,
4089                                               const EvaluateExpressionOptions& options)
4090 {
4091     lldb::ValueObjectSP retval_sp;
4092     lldb::TargetSP target_sp(exe_ctx.GetTargetSP());
4093     if (!target_sp)
4094         return retval_sp;
4095     if (!expression || !*expression)
4096         return retval_sp;
4097     target_sp->EvaluateExpression (expression,
4098                                    exe_ctx.GetFrameSP().get(),
4099                                    retval_sp,
4100                                    options);
4101     if (retval_sp && name && *name)
4102         retval_sp->SetName(ConstString(name));
4103     return retval_sp;
4104 }
4105 
4106 lldb::ValueObjectSP
4107 ValueObject::CreateValueObjectFromAddress (const char* name,
4108                                            uint64_t address,
4109                                            const ExecutionContext& exe_ctx,
4110                                            ClangASTType type)
4111 {
4112     if (type)
4113     {
4114         ClangASTType pointer_type(type.GetPointerType());
4115         if (pointer_type)
4116         {
4117             lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
4118             lldb::ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
4119                                                                                      pointer_type,
4120                                                                                      ConstString(name),
4121                                                                                      buffer,
4122                                                                                      exe_ctx.GetByteOrder(),
4123                                                                                      exe_ctx.GetAddressByteSize()));
4124             if (ptr_result_valobj_sp)
4125             {
4126                 ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress);
4127                 Error err;
4128                 ptr_result_valobj_sp = ptr_result_valobj_sp->Dereference(err);
4129                 if (ptr_result_valobj_sp && name && *name)
4130                     ptr_result_valobj_sp->SetName(ConstString(name));
4131             }
4132             return ptr_result_valobj_sp;
4133         }
4134     }
4135     return lldb::ValueObjectSP();
4136 }
4137 
4138 lldb::ValueObjectSP
4139 ValueObject::CreateValueObjectFromData (const char* name,
4140                                         const DataExtractor& data,
4141                                         const ExecutionContext& exe_ctx,
4142                                         ClangASTType type)
4143 {
4144     lldb::ValueObjectSP new_value_sp;
4145     new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
4146                                                    type,
4147                                                    ConstString(name),
4148                                                    data,
4149                                                    LLDB_INVALID_ADDRESS);
4150     new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
4151     if (new_value_sp && name && *name)
4152         new_value_sp->SetName(ConstString(name));
4153     return new_value_sp;
4154 }
4155 
4156 ModuleSP
4157 ValueObject::GetModule ()
4158 {
4159     ValueObject* root(GetRoot());
4160     if (root != this)
4161         return root->GetModule();
4162     return lldb::ModuleSP();
4163 }
4164 
4165 ValueObject*
4166 ValueObject::GetRoot ()
4167 {
4168     if (m_root)
4169         return m_root;
4170     return (m_root = FollowParentChain( [] (ValueObject* vo) -> bool {
4171         return (vo->m_parent != nullptr);
4172     }));
4173 }
4174 
4175 ValueObject*
4176 ValueObject::FollowParentChain (std::function<bool(ValueObject*)> f)
4177 {
4178     ValueObject* vo = this;
4179     while (vo)
4180     {
4181         if (f(vo) == false)
4182             break;
4183         vo = vo->m_parent;
4184     }
4185     return vo;
4186 }
4187 
4188 AddressType
4189 ValueObject::GetAddressTypeOfChildren()
4190 {
4191     if (m_address_type_of_ptr_or_ref_children == eAddressTypeInvalid)
4192     {
4193         ValueObject* root(GetRoot());
4194         if (root != this)
4195             return root->GetAddressTypeOfChildren();
4196     }
4197     return m_address_type_of_ptr_or_ref_children;
4198 }
4199 
4200 lldb::DynamicValueType
4201 ValueObject::GetDynamicValueType ()
4202 {
4203     ValueObject* with_dv_info = this;
4204     while (with_dv_info)
4205     {
4206         if (with_dv_info->HasDynamicValueTypeInfo())
4207             return with_dv_info->GetDynamicValueTypeImpl();
4208         with_dv_info = with_dv_info->m_parent;
4209     }
4210     return lldb::eNoDynamicValues;
4211 }
4212 
4213 lldb::Format
4214 ValueObject::GetFormat () const
4215 {
4216     const ValueObject* with_fmt_info = this;
4217     while (with_fmt_info)
4218     {
4219         if (with_fmt_info->m_format != lldb::eFormatDefault)
4220             return with_fmt_info->m_format;
4221         with_fmt_info = with_fmt_info->m_parent;
4222     }
4223     return m_format;
4224 }
4225 
4226 lldb::LanguageType
4227 ValueObject::GetPreferredDisplayLanguage ()
4228 {
4229     lldb::LanguageType type = m_preferred_display_language;
4230     if (m_preferred_display_language == lldb::eLanguageTypeUnknown)
4231     {
4232         if (GetRoot())
4233         {
4234             if (GetRoot() == this)
4235             {
4236                 if (StackFrameSP frame_sp = GetFrameSP())
4237                 {
4238                     const SymbolContext& sc(frame_sp->GetSymbolContext(eSymbolContextCompUnit));
4239                     if (CompileUnit* cu = sc.comp_unit)
4240                         type = cu->GetLanguage();
4241                 }
4242             }
4243             else
4244             {
4245                 type = GetRoot()->GetPreferredDisplayLanguage();
4246             }
4247         }
4248     }
4249     return (m_preferred_display_language = type); // only compute it once
4250 }
4251 
4252 void
4253 ValueObject::SetPreferredDisplayLanguage (lldb::LanguageType lt)
4254 {
4255     m_preferred_display_language = lt;
4256 }
4257 
4258 bool
4259 ValueObject::CanProvideValue ()
4260 {
4261     // we need to support invalid types as providers of values because some bare-board
4262     // debugging scenarios have no notion of types, but still manage to have raw numeric
4263     // values for things like registers. sigh.
4264     const ClangASTType &type(GetClangType());
4265     return (false == type.IsValid()) || (0 != (type.GetTypeInfo() & eTypeHasValue));
4266 }
4267 
4268 bool
4269 ValueObject::IsChecksumEmpty ()
4270 {
4271     return m_value_checksum.empty();
4272 }
4273 
4274 ValueObjectSP
4275 ValueObject::Persist ()
4276 {
4277     if (!UpdateValueIfNeeded())
4278         return nullptr;
4279 
4280     TargetSP target_sp(GetTargetSP());
4281     if (!target_sp)
4282         return nullptr;
4283 
4284     ConstString name(target_sp->GetPersistentVariables().GetNextPersistentVariableName());
4285 
4286     ClangExpressionVariableSP clang_var_sp(new ClangExpressionVariable(target_sp.get(), GetValue(), name));
4287     if (clang_var_sp)
4288     {
4289         clang_var_sp->m_live_sp = clang_var_sp->m_frozen_sp;
4290         clang_var_sp->m_flags |= ClangExpressionVariable::EVIsProgramReference;
4291         target_sp->GetPersistentVariables().AddVariable(clang_var_sp);
4292     }
4293 
4294     return clang_var_sp->GetValueObject();
4295 }
4296 
4297 bool
4298 ValueObject::IsSyntheticChildrenGenerated ()
4299 {
4300     return m_is_synthetic_children_generated;
4301 }
4302 
4303 void
4304 ValueObject::SetSyntheticChildrenGenerated (bool b)
4305 {
4306     m_is_synthetic_children_generated = b;
4307 }
4308