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