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