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