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