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