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