contrib/llvm/tools/lldb/source/Core/ValueObject.cpp

   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 }