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