Home | History | Annotate | Download | only in Core 
      1 //===-- ValueObject.cpp -----------------------------------------*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #include "lldb/lldb-python.h"
     11 
     12 #include "lldb/Core/ValueObject.h"
     13 
     14 // C Includes
     15 #include <stdlib.h>
     16 
     17 // C++ Includes
     18 // Other libraries and framework includes
     19 #include "llvm/Support/raw_ostream.h"
     20 #include "clang/AST/Type.h"
     21 
     22 // Project includes
     23 #include "lldb/Core/DataBufferHeap.h"
     24 #include "lldb/Core/Debugger.h"
     25 #include "lldb/Core/Log.h"
     26 #include "lldb/Core/Module.h"
     27 #include "lldb/Core/StreamString.h"
     28 #include "lldb/Core/ValueObjectCast.h"
     29 #include "lldb/Core/ValueObjectChild.h"
     30 #include "lldb/Core/ValueObjectConstResult.h"
     31 #include "lldb/Core/ValueObjectDynamicValue.h"
     32 #include "lldb/Core/ValueObjectList.h"
     33 #include "lldb/Core/ValueObjectMemory.h"
     34 #include "lldb/Core/ValueObjectSyntheticFilter.h"
     35 
     36 #include "lldb/DataFormatters/DataVisualization.h"
     37 
     38 #include "lldb/Host/Endian.h"
     39 
     40 #include "lldb/Interpreter/CommandInterpreter.h"
     41 #include "lldb/Interpreter/ScriptInterpreterPython.h"
     42 
     43 #include "lldb/Symbol/ClangASTType.h"
     44 #include "lldb/Symbol/ClangASTContext.h"
     45 #include "lldb/Symbol/Type.h"
     46 
     47 #include "lldb/Target/ExecutionContext.h"
     48 #include "lldb/Target/LanguageRuntime.h"
     49 #include "lldb/Target/ObjCLanguageRuntime.h"
     50 #include "lldb/Target/Process.h"
     51 #include "lldb/Target/RegisterContext.h"
     52 #include "lldb/Target/Target.h"
     53 #include "lldb/Target/Thread.h"
     54 
     55 using namespace lldb;
     56 using namespace lldb_private;
     57 using namespace lldb_utility;
     58 
     59 static user_id_t g_value_obj_uid = 0;
     60 
     61 //----------------------------------------------------------------------
     62 // ValueObject constructor
     63 //----------------------------------------------------------------------
     64 ValueObject::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 //----------------------------------------------------------------------
    109 ValueObject::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 //----------------------------------------------------------------------
    156 ValueObject::~ValueObject ()
    157 {
    158 }
    159 
    160 bool
    161 ValueObject::UpdateValueIfNeeded (bool update_format)
    162 {
    163 
    164     bool did_change_formats = false;
    165 
    166     if (update_format)
    167         did_change_formats = UpdateFormatsIfNeeded();
    168 
    169     // If this is a constant value, then our success is predicated on whether
    170     // we have an error or not
    171     if (GetIsConstant())
    172     {
    173         // if you were asked to update your formatters, but did not get a chance to do it
    174         // clear your own values (this serves the purpose of faking a stop-id for frozen
    175         // objects (which are regarded as constant, but could have changes behind their backs
    176         // because of the frozen-pointer depth limit)
    177 		// TODO: decouple summary from value and then remove this code and only force-clear the summary
    178         if (update_format && !did_change_formats)
    179             ClearUserVisibleData(eClearUserVisibleDataItemsSummary);
    180         return m_error.Success();
    181     }
    182 
    183     bool first_update = m_update_point.IsFirstEvaluation();
    184 
    185     if (m_update_point.NeedsUpdating())
    186     {
    187         m_update_point.SetUpdated();
    188 
    189         // Save the old value using swap to avoid a string copy which
    190         // also will clear our m_value_str
    191         if (m_value_str.empty())
    192         {
    193             m_old_value_valid = false;
    194         }
    195         else
    196         {
    197             m_old_value_valid = true;
    198             m_old_value_str.swap (m_value_str);
    199             ClearUserVisibleData(eClearUserVisibleDataItemsValue);
    200         }
    201 
    202         ClearUserVisibleData();
    203 
    204         if (IsInScope())
    205         {
    206             const bool value_was_valid = GetValueIsValid();
    207             SetValueDidChange (false);
    208 
    209             m_error.Clear();
    210 
    211             // Call the pure virtual function to update the value
    212             bool success = UpdateValue ();
    213 
    214             SetValueIsValid (success);
    215 
    216             if (first_update)
    217                 SetValueDidChange (false);
    218             else if (!m_value_did_change && success == false)
    219             {
    220                 // The value wasn't gotten successfully, so we mark this
    221                 // as changed if the value used to be valid and now isn't
    222                 SetValueDidChange (value_was_valid);
    223             }
    224         }
    225         else
    226         {
    227             m_error.SetErrorString("out of scope");
    228         }
    229     }
    230     return m_error.Success();
    231 }
    232 
    233 bool
    234 ValueObject::UpdateFormatsIfNeeded()
    235 {
    236     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 
    263 void
    264 ValueObject::SetNeedsUpdate ()
    265 {
    266     m_update_point.SetNeedsUpdate();
    267     // We have to clear the value string here so ConstResult children will notice if their values are
    268     // changed by hand (i.e. with SetValueAsCString).
    269     ClearUserVisibleData(eClearUserVisibleDataItemsValue);
    270 }
    271 
    272 void
    273 ValueObject::ClearDynamicTypeInformation ()
    274 {
    275     m_did_calculate_complete_objc_class_type = false;
    276     m_last_format_mgr_revision = 0;
    277     m_override_type = ClangASTType();
    278     SetValueFormat(lldb::TypeFormatImplSP());
    279     SetSummaryFormat(lldb::TypeSummaryImplSP());
    280     SetSyntheticChildren(lldb::SyntheticChildrenSP());
    281 }
    282 
    283 ClangASTType
    284 ValueObject::MaybeCalculateCompleteType ()
    285 {
    286     ClangASTType 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 
    356 ClangASTType
    357 ValueObject::GetClangType ()
    358 {
    359     return MaybeCalculateCompleteType();
    360 }
    361 
    362 DataExtractor &
    363 ValueObject::GetDataExtractor ()
    364 {
    365     UpdateValueIfNeeded(false);
    366     return m_data;
    367 }
    368 
    369 const Error &
    370 ValueObject::GetError()
    371 {
    372     UpdateValueIfNeeded(false);
    373     return m_error;
    374 }
    375 
    376 const ConstString &
    377 ValueObject::GetName() const
    378 {
    379     return m_name;
    380 }
    381 
    382 const char *
    383 ValueObject::GetLocationAsCString ()
    384 {
    385     return GetLocationAsCStringImpl(m_value,
    386                                     m_data);
    387 }
    388 
    389 const char *
    390 ValueObject::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 
    437 Value &
    438 ValueObject::GetValue()
    439 {
    440     return m_value;
    441 }
    442 
    443 const Value &
    444 ValueObject::GetValue() const
    445 {
    446     return m_value;
    447 }
    448 
    449 bool
    450 ValueObject::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 
    468 bool
    469 ValueObject::GetValueIsValid () const
    470 {
    471     return m_value_is_valid;
    472 }
    473 
    474 
    475 void
    476 ValueObject::SetValueIsValid (bool b)
    477 {
    478     m_value_is_valid = b;
    479 }
    480 
    481 bool
    482 ValueObject::GetValueDidChange ()
    483 {
    484     GetValueAsCString ();
    485     return m_value_did_change;
    486 }
    487 
    488 void
    489 ValueObject::SetValueDidChange (bool value_changed)
    490 {
    491     m_value_did_change = value_changed;
    492 }
    493 
    494 ValueObjectSP
    495 ValueObject::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 
    518 ValueObjectSP
    519 ValueObject::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 
    538 ValueObjectSP
    539 ValueObject::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 
    558 lldb::ValueObjectSP
    559 ValueObject::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 
    578 lldb::ValueObjectSP
    579 ValueObject::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 
    598 size_t
    599 ValueObject::GetIndexOfChildWithName (const ConstString &name)
    600 {
    601     bool omit_empty_base_classes = true;
    602     return GetClangType().GetIndexOfChildWithName (name.GetCString(), omit_empty_base_classes);
    603 }
    604 
    605 ValueObjectSP
    606 ValueObject::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 
    646 size_t
    647 ValueObject::GetNumChildren ()
    648 {
    649     UpdateValueIfNeeded();
    650     if (!m_children_count_valid)
    651     {
    652         SetNumChildren (CalculateNumChildren());
    653     }
    654     return m_children.GetChildrenCount();
    655 }
    656 
    657 bool
    658 ValueObject::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()
    677 void
    678 ValueObject::SetNumChildren (size_t num_children)
    679 {
    680     m_children_count_valid = true;
    681     m_children.SetChildrenCount(num_children);
    682 }
    683 
    684 void
    685 ValueObject::SetName (const ConstString &name)
    686 {
    687     m_name = name;
    688 }
    689 
    690 ValueObject *
    691 ValueObject::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 
    749 bool
    750 ValueObject::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 
    834 const char *
    835 ValueObject::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 
    847 bool
    848 ValueObject::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 
    866 size_t
    867 ValueObject::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 
    973 uint64_t
    974 ValueObject::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 
    996 bool
    997 ValueObject::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)
   1081 static uint32_t
   1082 strlen_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 
   1099 size_t
   1100 ValueObject::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 
   1258 const char *
   1259 ValueObject::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 
   1303 bool
   1304 ValueObject::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 
   1387 const char *
   1388 ValueObject::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
   1437 uint64_t
   1438 ValueObject::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
   1461 bool
   1462 ValueObject::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 
   1500 bool
   1501 ValueObject::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 
   1726 addr_t
   1727 ValueObject::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 
   1759 addr_t
   1760 ValueObject::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 
   1792 bool
   1793 ValueObject::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 
   1893 bool
   1894 ValueObject::GetDeclaration (Declaration &decl)
   1895 {
   1896     decl.Clear();
   1897     return false;
   1898 }
   1899 
   1900 ConstString
   1901 ValueObject::GetTypeName()
   1902 {
   1903     return GetClangType().GetConstTypeName();
   1904 }
   1905 
   1906 ConstString
   1907 ValueObject::GetQualifiedTypeName()
   1908 {
   1909     return GetClangType().GetConstQualifiedTypeName();
   1910 }
   1911 
   1912 
   1913 LanguageType
   1914 ValueObject::GetObjectRuntimeLanguage ()
   1915 {
   1916     return GetClangType().GetMinimumLanguage ();
   1917 }
   1918 
   1919 void
   1920 ValueObject::AddSyntheticChild (const ConstString &key, ValueObject *valobj)
   1921 {
   1922     m_synthetic_children[key] = valobj;
   1923 }
   1924 
   1925 ValueObjectSP
   1926 ValueObject::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 
   1935 uint32_t
   1936 ValueObject::GetTypeInfo (ClangASTType *pointee_or_element_clang_type)
   1937 {
   1938     return GetClangType().GetTypeInfo (pointee_or_element_clang_type);
   1939 }
   1940 
   1941 bool
   1942 ValueObject::IsPointerType ()
   1943 {
   1944     return GetClangType().IsPointerType();
   1945 }
   1946 
   1947 bool
   1948 ValueObject::IsArrayType ()
   1949 {
   1950     return GetClangType().IsArrayType (NULL, NULL, NULL);
   1951 }
   1952 
   1953 bool
   1954 ValueObject::IsScalarType ()
   1955 {
   1956     return GetClangType().IsScalarType ();
   1957 }
   1958 
   1959 bool
   1960 ValueObject::IsIntegerType (bool &is_signed)
   1961 {
   1962     return GetClangType().IsIntegerType (is_signed);
   1963 }
   1964 
   1965 bool
   1966 ValueObject::IsPointerOrReferenceType ()
   1967 {
   1968     return GetClangType().IsPointerOrReferenceType ();
   1969 }
   1970 
   1971 bool
   1972 ValueObject::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 
   1982 bool
   1983 ValueObject::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 
   1994 ValueObjectSP
   1995 ValueObject::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 
   2008 ValueObjectSP
   2009 ValueObject::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 
   2051 ValueObjectSP
   2052 ValueObject::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 
   2083 ValueObjectSP
   2084 ValueObject::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 
   2123 ValueObjectSP
   2124 ValueObject::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
   2168 static const char*
   2169 SkipLeadingExpressionPathSeparators(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 
   2180 ValueObjectSP
   2181 ValueObject::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 
   2207 void
   2208 ValueObject::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 
   2234 void
   2235 ValueObject::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 
   2252 ValueObjectSP
   2253 ValueObject::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 
   2268 ValueObjectSP
   2269 ValueObject::GetStaticValue()
   2270 {
   2271     return GetSP();
   2272 }
   2273 
   2274 lldb::ValueObjectSP
   2275 ValueObject::GetNonSyntheticValue ()
   2276 {
   2277     return GetSP();
   2278 }
   2279 
   2280 ValueObjectSP
   2281 ValueObject::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 
   2294 bool
   2295 ValueObject::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 
   2310 bool
   2311 ValueObject::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 
   2331 ValueObject *
   2332 ValueObject::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 
   2344 void
   2345 ValueObject::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 
   2418 ValueObjectSP
   2419 ValueObject::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 
   2486 int
   2487 ValueObject::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 
   2576 ValueObjectSP
   2577 ValueObject::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 
   3050 int
   3051 ValueObject::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 
   3345 static void
   3346 DumpValueObject_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 
   3620 void
   3621 ValueObject::LogValueObject (Log *log,
   3622                              ValueObject *valobj)
   3623 {
   3624     if (log && valobj)
   3625         return LogValueObject (log, valobj, DumpValueObjectOptions::DefaultOptions());
   3626 }
   3627 
   3628 void
   3629 ValueObject::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 
   3642 void
   3643 ValueObject::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 
   3657 void
   3658 ValueObject::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 
   3670 ValueObjectSP
   3671 ValueObject::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 
   3705 ValueObjectSP
   3706 ValueObject::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 
   3780 ValueObjectSP
   3781 ValueObject::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 
   3833 ValueObjectSP
   3834 ValueObject::Cast (const ClangASTType &clang_ast_type)
   3835 {
   3836     return ValueObjectCast::Create (*this, GetName(), clang_ast_type);
   3837 }
   3838 
   3839 ValueObjectSP
   3840 ValueObject::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 
   3858 ValueObjectSP
   3859 ValueObject::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 
   3877 ValueObject::EvaluationPoint::EvaluationPoint () :
   3878     m_mod_id(),
   3879     m_exe_ctx_ref(),
   3880     m_needs_update (true),
   3881     m_first_update (true)
   3882 {
   3883 }
   3884 
   3885 ValueObject::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 
   3930 ValueObject::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 
   3938 ValueObject::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 
   3949 bool
   3950 ValueObject::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 
   4021 void
   4022 ValueObject::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 
   4033 void
   4034 ValueObject::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 
   4057 SymbolContextScope *
   4058 ValueObject::GetSymbolContextScope()
   4059 {
   4060     if (m_parent)
   4061     {
   4062         if (!m_parent->IsPointerOrReferenceType())
   4063             return m_parent->GetSymbolContextScope();
   4064     }
   4065     return NULL;
   4066 }
   4067 
   4068 lldb::ValueObjectSP
   4069 ValueObject::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 
   4087 lldb::ValueObjectSP
   4088 ValueObject::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 
   4119 lldb::ValueObjectSP
   4120 ValueObject::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 
   4137 ModuleSP
   4138 ValueObject::GetModule ()
   4139 {
   4140     ValueObject* root(GetRoot());
   4141     if (root != this)
   4142         return root->GetModule();
   4143     return lldb::ModuleSP();
   4144 }
   4145 
   4146 ValueObject*
   4147 ValueObject::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 
   4163 AddressType
   4164 ValueObject::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 
   4175 lldb::DynamicValueType
   4176 ValueObject::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 
   4188 lldb::Format
   4189 ValueObject::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