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