contrib/llvm/tools/lldb/include/lldb/Core/ValueObject.h

   1 //===-- ValueObject.h -------------------------------------------*- 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 #ifndef liblldb_ValueObject_h_
  11 #define liblldb_ValueObject_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 #include <initializer_list>
  16 #include <map>
  17 #include <vector>
  18 // Other libraries and framework includes
  19 // Project includes
  20
  21 #include "lldb/lldb-private.h"
  22 #include "lldb/Core/DataExtractor.h"
  23 #include "lldb/Core/Error.h"
  24 #include "lldb/Core/Flags.h"
  25 #include "lldb/Core/ConstString.h"
  26 #include "lldb/Core/UserID.h"
  27 #include "lldb/Core/Value.h"
  28 #include "lldb/Target/ExecutionContext.h"
  29 #include "lldb/Target/ExecutionContextScope.h"
  30 #include "lldb/Target/Process.h"
  31 #include "lldb/Target/StackID.h"
  32 #include "lldb/Utility/SharedCluster.h"
  33
  34 namespace lldb_private {
  35
  36 /// ValueObject:
  37 ///
  38 /// This abstract class provides an interface to a particular value, be it a register, a local or global variable,
  39 /// that is evaluated in some particular scope.  The ValueObject also has the capibility of being the "child" of
  40 /// some other variable object, and in turn of having children.
  41 /// If a ValueObject is a root variable object - having no parent - then it must be constructed with respect to some
  42 /// particular ExecutionContextScope.  If it is a child, it inherits the ExecutionContextScope from its parent.
  43 /// The ValueObject will update itself if necessary before fetching its value, summary, object description, etc.
  44 /// But it will always update itself in the ExecutionContextScope with which it was originally created.
  45
  46 /// A brief note on life cycle management for ValueObjects.  This is a little tricky because a ValueObject can contain
  47 /// various other ValueObjects - the Dynamic Value, its children, the dereference value, etc.  Any one of these can be
  48 /// handed out as a shared pointer, but for that contained value object to be valid, the root object and potentially other
  49 /// of the value objects need to stay around.
  50 /// We solve this problem by handing out shared pointers to the Value Object and any of its dependents using a shared
  51 /// ClusterManager.  This treats each shared pointer handed out for the entire cluster as a reference to the whole
  52 /// cluster.  The whole cluster will stay around until the last reference is released.
  53 ///
  54 /// The ValueObject mostly handle this automatically, if a value object is made with a Parent ValueObject, then it adds
  55 /// itself to the ClusterManager of the parent.
  56
  57 /// It does mean that external to the ValueObjects we should only ever make available ValueObjectSP's, never ValueObjects
  58 /// or pointers to them.  So all the "Root level" ValueObject derived constructors should be private, and
  59 /// should implement a Create function that new's up object and returns a Shared Pointer that it gets from the GetSP() method.
  60 ///
  61 /// However, if you are making an derived ValueObject that will be contained in a parent value object, you should just
  62 /// hold onto a pointer to it internally, and by virtue of passing the parent ValueObject into its constructor, it will
  63 /// be added to the ClusterManager for the parent.  Then if you ever hand out a Shared Pointer to the contained ValueObject,
  64 /// just do so by calling GetSP() on the contained object.
  65
  66 class ValueObject : public UserID
  67 {
  68 public:
  69
  70     enum GetExpressionPathFormat
  71     {
  72         eGetExpressionPathFormatDereferencePointers = 1,
  73         eGetExpressionPathFormatHonorPointers
  74     };
  75
  76     enum ValueObjectRepresentationStyle
  77     {
  78         eValueObjectRepresentationStyleValue = 1,
  79         eValueObjectRepresentationStyleSummary,
  80         eValueObjectRepresentationStyleLanguageSpecific,
  81         eValueObjectRepresentationStyleLocation,
  82         eValueObjectRepresentationStyleChildrenCount,
  83         eValueObjectRepresentationStyleType,
  84         eValueObjectRepresentationStyleName,
  85         eValueObjectRepresentationStyleExpressionPath
  86     };
  87
  88     enum ExpressionPathScanEndReason
  89     {
  90         eExpressionPathScanEndReasonEndOfString = 1,           // out of data to parse
  91         eExpressionPathScanEndReasonNoSuchChild,               // child element not found
  92         eExpressionPathScanEndReasonEmptyRangeNotAllowed,      // [] only allowed for arrays
  93         eExpressionPathScanEndReasonDotInsteadOfArrow,         // . used when -> should be used
  94         eExpressionPathScanEndReasonArrowInsteadOfDot,         // -> used when . should be used
  95         eExpressionPathScanEndReasonFragileIVarNotAllowed,     // ObjC ivar expansion not allowed
  96         eExpressionPathScanEndReasonRangeOperatorNotAllowed,   // [] not allowed by options
  97         eExpressionPathScanEndReasonRangeOperatorInvalid,      // [] not valid on objects other than scalars, pointers or arrays
  98         eExpressionPathScanEndReasonArrayRangeOperatorMet,     // [] is good for arrays, but I cannot parse it
  99         eExpressionPathScanEndReasonBitfieldRangeOperatorMet,  // [] is good for bitfields, but I cannot parse after it
 100         eExpressionPathScanEndReasonUnexpectedSymbol,          // something is malformed in the expression
 101         eExpressionPathScanEndReasonTakingAddressFailed,       // impossible to apply & operator
 102         eExpressionPathScanEndReasonDereferencingFailed,       // impossible to apply * operator
 103         eExpressionPathScanEndReasonRangeOperatorExpanded,     // [] was expanded into a VOList
 104         eExpressionPathScanEndReasonSyntheticValueMissing,     // getting the synthetic children failed
 105         eExpressionPathScanEndReasonUnknown = 0xFFFF
 106     };
 107
 108     enum ExpressionPathEndResultType
 109     {
 110         eExpressionPathEndResultTypePlain = 1,                 // anything but...
 111         eExpressionPathEndResultTypeBitfield,                  // a bitfield
 112         eExpressionPathEndResultTypeBoundedRange,              // a range [low-high]
 113         eExpressionPathEndResultTypeUnboundedRange,            // a range []
 114         eExpressionPathEndResultTypeValueObjectList,           // several items in a VOList
 115         eExpressionPathEndResultTypeInvalid = 0xFFFF
 116     };
 117
 118     enum ExpressionPathAftermath
 119     {
 120         eExpressionPathAftermathNothing = 1,               // just return it
 121         eExpressionPathAftermathDereference,               // dereference the target
 122         eExpressionPathAftermathTakeAddress                // take target's address
 123     };
 124
 125     enum ClearUserVisibleDataItems
 126     {
 127         eClearUserVisibleDataItemsNothing = 1u << 0,
 128         eClearUserVisibleDataItemsValue = 1u << 1,
 129         eClearUserVisibleDataItemsSummary = 1u << 2,
 130         eClearUserVisibleDataItemsLocation = 1u << 3,
 131         eClearUserVisibleDataItemsDescription = 1u << 4,
 132         eClearUserVisibleDataItemsSyntheticChildren = 1u << 5,
 133         eClearUserVisibleDataItemsAllStrings = eClearUserVisibleDataItemsValue | eClearUserVisibleDataItemsSummary | eClearUserVisibleDataItemsLocation | eClearUserVisibleDataItemsDescription,
 134         eClearUserVisibleDataItemsAll = 0xFFFF
 135     };
 136
 137     struct GetValueForExpressionPathOptions
 138     {
 139         bool m_check_dot_vs_arrow_syntax;
 140         bool m_no_fragile_ivar;
 141         bool m_allow_bitfields_syntax;
 142         bool m_no_synthetic_children;
 143
 144         GetValueForExpressionPathOptions(bool dot = false,
 145                                          bool no_ivar = false,
 146                                          bool bitfield = true,
 147                                          bool no_synth = false) :
 148             m_check_dot_vs_arrow_syntax(dot),
 149             m_no_fragile_ivar(no_ivar),
 150             m_allow_bitfields_syntax(bitfield),
 151             m_no_synthetic_children(no_synth)
 152         {
 153         }
 154
 155         GetValueForExpressionPathOptions&
 156         DoCheckDotVsArrowSyntax()
 157         {
 158             m_check_dot_vs_arrow_syntax = true;
 159             return *this;
 160         }
 161
 162         GetValueForExpressionPathOptions&
 163         DontCheckDotVsArrowSyntax()
 164         {
 165             m_check_dot_vs_arrow_syntax = false;
 166             return *this;
 167         }
 168
 169         GetValueForExpressionPathOptions&
 170         DoAllowFragileIVar()
 171         {
 172             m_no_fragile_ivar = false;
 173             return *this;
 174         }
 175
 176         GetValueForExpressionPathOptions&
 177         DontAllowFragileIVar()
 178         {
 179             m_no_fragile_ivar = true;
 180             return *this;
 181         }
 182
 183         GetValueForExpressionPathOptions&
 184         DoAllowBitfieldSyntax()
 185         {
 186             m_allow_bitfields_syntax = true;
 187             return *this;
 188         }
 189
 190         GetValueForExpressionPathOptions&
 191         DontAllowBitfieldSyntax()
 192         {
 193             m_allow_bitfields_syntax = false;
 194             return *this;
 195         }
 196
 197         GetValueForExpressionPathOptions&
 198         DoAllowSyntheticChildren()
 199         {
 200             m_no_synthetic_children = false;
 201             return *this;
 202         }
 203
 204         GetValueForExpressionPathOptions&
 205         DontAllowSyntheticChildren()
 206         {
 207             m_no_synthetic_children = true;
 208             return *this;
 209         }
 210
 211         static const GetValueForExpressionPathOptions
 212         DefaultOptions()
 213         {
 214             static GetValueForExpressionPathOptions g_default_options;
 215
 216             return g_default_options;
 217         }
 218
 219     };
 220
 221     struct DumpValueObjectOptions
 222     {
 223         uint32_t m_max_ptr_depth;
 224         uint32_t m_max_depth;
 225         bool m_show_types;
 226         bool m_show_location;
 227         bool m_use_objc;
 228         lldb::DynamicValueType m_use_dynamic;
 229         bool m_use_synthetic;
 230         bool m_scope_already_checked;
 231         bool m_flat_output;
 232         uint32_t m_omit_summary_depth;
 233         bool m_ignore_cap;
 234         lldb::Format m_format;
 235         lldb::TypeSummaryImplSP m_summary_sp;
 236         std::string m_root_valobj_name;
 237         bool m_hide_root_type;
 238         bool m_hide_name;
 239         bool m_hide_value;
 240
 241         DumpValueObjectOptions() :
 242             m_max_ptr_depth(0),
 243             m_max_depth(UINT32_MAX),
 244             m_show_types(false),
 245             m_show_location(false),
 246             m_use_objc(false),
 247             m_use_dynamic(lldb::eNoDynamicValues),
 248             m_use_synthetic(true),
 249             m_scope_already_checked(false),
 250             m_flat_output(false),
 251             m_omit_summary_depth(0),
 252             m_ignore_cap(false),
 253             m_format (lldb::eFormatDefault),
 254             m_summary_sp(),
 255             m_root_valobj_name(),
 256             m_hide_root_type(false),  // provide a special compact display for "po"
 257             m_hide_name(false), // provide a special compact display for "po"
 258             m_hide_value(false) // provide a special compact display for "po"
 259         {}
 260
 261         static const DumpValueObjectOptions
 262         DefaultOptions()
 263         {
 264             static DumpValueObjectOptions g_default_options;
 265
 266             return g_default_options;
 267         }
 268
 269         DumpValueObjectOptions (const DumpValueObjectOptions& rhs) :
 270             m_max_ptr_depth(rhs.m_max_ptr_depth),
 271             m_max_depth(rhs.m_max_depth),
 272             m_show_types(rhs.m_show_types),
 273             m_show_location(rhs.m_show_location),
 274             m_use_objc(rhs.m_use_objc),
 275             m_use_dynamic(rhs.m_use_dynamic),
 276             m_use_synthetic(rhs.m_use_synthetic),
 277             m_scope_already_checked(rhs.m_scope_already_checked),
 278             m_flat_output(rhs.m_flat_output),
 279             m_omit_summary_depth(rhs.m_omit_summary_depth),
 280             m_ignore_cap(rhs.m_ignore_cap),
 281             m_format(rhs.m_format),
 282             m_summary_sp(rhs.m_summary_sp),
 283             m_root_valobj_name(rhs.m_root_valobj_name),
 284             m_hide_root_type(rhs.m_hide_root_type),
 285             m_hide_name(rhs.m_hide_name),
 286             m_hide_value(rhs.m_hide_value)
 287         {}
 288
 289         DumpValueObjectOptions&
 290         SetMaximumPointerDepth(uint32_t depth = 0)
 291         {
 292             m_max_ptr_depth = depth;
 293             return *this;
 294         }
 295
 296         DumpValueObjectOptions&
 297         SetMaximumDepth(uint32_t depth = 0)
 298         {
 299             m_max_depth = depth;
 300             return *this;
 301         }
 302
 303         DumpValueObjectOptions&
 304         SetShowTypes(bool show = false)
 305         {
 306             m_show_types = show;
 307             return *this;
 308         }
 309
 310         DumpValueObjectOptions&
 311         SetShowLocation(bool show = false)
 312         {
 313             m_show_location = show;
 314             return *this;
 315         }
 316
 317         DumpValueObjectOptions&
 318         SetUseObjectiveC(bool use = false)
 319         {
 320             m_use_objc = use;
 321             return *this;
 322         }
 323
 324         DumpValueObjectOptions&
 325         SetShowSummary(bool show = true)
 326         {
 327             if (show == false)
 328                 SetOmitSummaryDepth(UINT32_MAX);
 329             else
 330                 SetOmitSummaryDepth(0);
 331             return *this;
 332         }
 333
 334         DumpValueObjectOptions&
 335         SetUseDynamicType(lldb::DynamicValueType dyn = lldb::eNoDynamicValues)
 336         {
 337             m_use_dynamic = dyn;
 338             return *this;
 339         }
 340
 341         DumpValueObjectOptions&
 342         SetUseSyntheticValue(bool use_synthetic = true)
 343         {
 344             m_use_synthetic = use_synthetic;
 345             return *this;
 346         }
 347
 348         DumpValueObjectOptions&
 349         SetScopeChecked(bool check = true)
 350         {
 351             m_scope_already_checked = check;
 352             return *this;
 353         }
 354
 355         DumpValueObjectOptions&
 356         SetFlatOutput(bool flat = false)
 357         {
 358             m_flat_output = flat;
 359             return *this;
 360         }
 361
 362         DumpValueObjectOptions&
 363         SetOmitSummaryDepth(uint32_t depth = 0)
 364         {
 365             m_omit_summary_depth = depth;
 366             return *this;
 367         }
 368
 369         DumpValueObjectOptions&
 370         SetIgnoreCap(bool ignore = false)
 371         {
 372             m_ignore_cap = ignore;
 373             return *this;
 374         }
 375
 376         DumpValueObjectOptions&
 377         SetRawDisplay(bool raw = false)
 378         {
 379             if (raw)
 380             {
 381                 SetUseSyntheticValue(false);
 382                 SetOmitSummaryDepth(UINT32_MAX);
 383                 SetIgnoreCap(true);
 384                 SetHideName(false);
 385                 SetHideValue(false);
 386             }
 387             else
 388             {
 389                 SetUseSyntheticValue(true);
 390                 SetOmitSummaryDepth(0);
 391                 SetIgnoreCap(false);
 392                 SetHideName(false);
 393                 SetHideValue(false);
 394             }
 395             return *this;
 396         }
 397
 398         DumpValueObjectOptions&
 399         SetFormat (lldb::Format format = lldb::eFormatDefault)
 400         {
 401             m_format = format;
 402             return *this;
 403         }
 404
 405         DumpValueObjectOptions&
 406         SetSummary (lldb::TypeSummaryImplSP summary = lldb::TypeSummaryImplSP())
 407         {
 408             m_summary_sp = summary;
 409             return *this;
 410         }
 411
 412         DumpValueObjectOptions&
 413         SetRootValueObjectName (const char* name = NULL)
 414         {
 415             if (name)
 416                 m_root_valobj_name.assign(name);
 417             else
 418                 m_root_valobj_name.clear();
 419             return *this;
 420         }
 421
 422         DumpValueObjectOptions&
 423         SetHideRootType (bool hide_root_type = false)
 424         {
 425             m_hide_root_type = hide_root_type;
 426             return *this;
 427         }
 428
 429         DumpValueObjectOptions&
 430         SetHideName (bool hide_name = false)
 431         {
 432             m_hide_name = hide_name;
 433             return *this;
 434         }
 435
 436         DumpValueObjectOptions&
 437         SetHideValue (bool hide_value = false)
 438         {
 439             m_hide_value = hide_value;
 440             return *this;
 441         }
 442     };
 443
 444     class EvaluationPoint
 445     {
 446     public:
 447
 448         EvaluationPoint ();
 449
 450         EvaluationPoint (ExecutionContextScope *exe_scope, bool use_selected = false);
 451
 452         EvaluationPoint (const EvaluationPoint &rhs);
 453
 454         ~EvaluationPoint ();
 455
 456         const ExecutionContextRef &
 457         GetExecutionContextRef() const
 458         {
 459             return m_exe_ctx_ref;
 460         }
 461
 462         // Set the EvaluationPoint to the values in exe_scope,
 463         // Return true if the Evaluation Point changed.
 464         // Since the ExecutionContextScope is always going to be valid currently,
 465         // the Updated Context will also always be valid.
 466
 467 //        bool
 468 //        SetContext (ExecutionContextScope *exe_scope);
 469
 470         void
 471         SetIsConstant ()
 472         {
 473             SetUpdated();
 474             m_mod_id.SetInvalid();
 475         }
 476
 477         bool
 478         IsConstant () const
 479         {
 480             return !m_mod_id.IsValid();
 481         }
 482
 483         ProcessModID
 484         GetModID () const
 485         {
 486             return m_mod_id;
 487         }
 488
 489         void
 490         SetUpdateID (ProcessModID new_id)
 491         {
 492             m_mod_id = new_id;
 493         }
 494
 495         bool
 496         IsFirstEvaluation () const
 497         {
 498             return m_first_update;
 499         }
 500
 501         void
 502         SetNeedsUpdate ()
 503         {
 504             m_needs_update = true;
 505         }
 506
 507         void
 508         SetUpdated ();
 509
 510         bool
 511         NeedsUpdating()
 512         {
 513             SyncWithProcessState();
 514             return m_needs_update;
 515         }
 516
 517         bool
 518         IsValid ()
 519         {
 520             if (!m_mod_id.IsValid())
 521                 return false;
 522             else if (SyncWithProcessState ())
 523             {
 524                 if (!m_mod_id.IsValid())
 525                     return false;
 526             }
 527             return true;
 528         }
 529
 530         void
 531         SetInvalid ()
 532         {
 533             // Use the stop id to mark us as invalid, leave the thread id and the stack id around for logging and
 534             // history purposes.
 535             m_mod_id.SetInvalid();
 536
 537             // Can't update an invalid state.
 538             m_needs_update = false;
 539
 540         }
 541
 542     private:
 543         bool
 544         SyncWithProcessState ();
 545
 546         ProcessModID m_mod_id; // This is the stop id when this ValueObject was last evaluated.
 547         ExecutionContextRef m_exe_ctx_ref;
 548         bool m_needs_update;
 549         bool m_first_update;
 550     };
 551
 552     const EvaluationPoint &
 553     GetUpdatePoint () const
 554     {
 555         return m_update_point;
 556     }
 557
 558     EvaluationPoint &
 559     GetUpdatePoint ()
 560     {
 561         return m_update_point;
 562     }
 563
 564     const ExecutionContextRef &
 565     GetExecutionContextRef() const
 566     {
 567         return m_update_point.GetExecutionContextRef();
 568     }
 569
 570     lldb::TargetSP
 571     GetTargetSP() const
 572     {
 573         return m_update_point.GetExecutionContextRef().GetTargetSP();
 574     }
 575
 576     lldb::ProcessSP
 577     GetProcessSP() const
 578     {
 579         return m_update_point.GetExecutionContextRef().GetProcessSP();
 580     }
 581
 582     lldb::ThreadSP
 583     GetThreadSP() const
 584     {
 585         return m_update_point.GetExecutionContextRef().GetThreadSP();
 586     }
 587
 588     lldb::StackFrameSP
 589     GetFrameSP() const
 590     {
 591         return m_update_point.GetExecutionContextRef().GetFrameSP();
 592     }
 593
 594     void
 595     SetNeedsUpdate ();
 596
 597     virtual ~ValueObject();
 598
 599     ClangASTType
 600     GetClangType ();
 601
 602     //------------------------------------------------------------------
 603     // Sublasses must implement the functions below.
 604     //------------------------------------------------------------------
 605     virtual uint64_t
 606     GetByteSize() = 0;
 607
 608     virtual lldb::ValueType
 609     GetValueType() const = 0;
 610
 611     //------------------------------------------------------------------
 612     // Sublasses can implement the functions below.
 613     //------------------------------------------------------------------
 614     virtual ConstString
 615     GetTypeName();
 616
 617     virtual ConstString
 618     GetQualifiedTypeName();
 619
 620     virtual lldb::LanguageType
 621     GetObjectRuntimeLanguage();
 622
 623     virtual uint32_t
 624     GetTypeInfo (ClangASTType *pointee_or_element_clang_type = NULL);
 625
 626     virtual bool
 627     IsPointerType ();
 628
 629     virtual bool
 630     IsArrayType ();
 631
 632     virtual bool
 633     IsScalarType ();
 634
 635     virtual bool
 636     IsPointerOrReferenceType ();
 637
 638     virtual bool
 639     IsPossibleDynamicType ();
 640
 641     virtual bool
 642     IsObjCNil ();
 643
 644     virtual bool
 645     IsBaseClass ()
 646     {
 647         return false;
 648     }
 649
 650     virtual bool
 651     IsDereferenceOfParent ()
 652     {
 653         return false;
 654     }
 655
 656     bool
 657     IsIntegerType (bool &is_signed);
 658
 659     virtual bool
 660     GetBaseClassPath (Stream &s);
 661
 662     virtual void
 663     GetExpressionPath (Stream &s, bool qualify_cxx_base_classes, GetExpressionPathFormat = eGetExpressionPathFormatDereferencePointers);
 664
 665     lldb::ValueObjectSP
 666     GetValueForExpressionPath(const char* expression,
 667                               const char** first_unparsed = NULL,
 668                               ExpressionPathScanEndReason* reason_to_stop = NULL,
 669                               ExpressionPathEndResultType* final_value_type = NULL,
 670                               const GetValueForExpressionPathOptions& options = GetValueForExpressionPathOptions::DefaultOptions(),
 671                               ExpressionPathAftermath* final_task_on_target = NULL);
 672
 673     int
 674     GetValuesForExpressionPath(const char* expression,
 675                                lldb::ValueObjectListSP& list,
 676                                const char** first_unparsed = NULL,
 677                                ExpressionPathScanEndReason* reason_to_stop = NULL,
 678                                ExpressionPathEndResultType* final_value_type = NULL,
 679                                const GetValueForExpressionPathOptions& options = GetValueForExpressionPathOptions::DefaultOptions(),
 680                                ExpressionPathAftermath* final_task_on_target = NULL);
 681
 682     virtual bool
 683     IsInScope ()
 684     {
 685         return true;
 686     }
 687
 688     virtual off_t
 689     GetByteOffset()
 690     {
 691         return 0;
 692     }
 693
 694     virtual uint32_t
 695     GetBitfieldBitSize ()
 696     {
 697         return 0;
 698     }
 699
 700     virtual uint32_t
 701     GetBitfieldBitOffset ()
 702     {
 703         return 0;
 704     }
 705
 706     bool
 707     IsBitfield ()
 708     {
 709         return (GetBitfieldBitSize() != 0) || (GetBitfieldBitOffset() != 0);
 710     }
 711
 712     virtual bool
 713     IsArrayItemForPointer()
 714     {
 715         return m_is_array_item_for_pointer;
 716     }
 717
 718     virtual const char *
 719     GetValueAsCString ();
 720
 721     virtual bool
 722     GetValueAsCString (lldb::Format format,
 723                        std::string& destination);
 724
 725     virtual uint64_t
 726     GetValueAsUnsigned (uint64_t fail_value, bool *success = NULL);
 727
 728     virtual bool
 729     SetValueFromCString (const char *value_str, Error& error);
 730
 731     // Return the module associated with this value object in case the
 732     // value is from an executable file and might have its data in
 733     // sections of the file. This can be used for variables.
 734     virtual lldb::ModuleSP
 735     GetModule();
 736
 737     virtual ValueObject*
 738     GetRoot ();
 739
 740     virtual bool
 741     GetDeclaration (Declaration &decl);
 742
 743     //------------------------------------------------------------------
 744     // The functions below should NOT be modified by sublasses
 745     //------------------------------------------------------------------
 746     const Error &
 747     GetError();
 748
 749     const ConstString &
 750     GetName() const;
 751
 752     virtual lldb::ValueObjectSP
 753     GetChildAtIndex (size_t idx, bool can_create);
 754
 755     // this will always create the children if necessary
 756     lldb::ValueObjectSP
 757     GetChildAtIndexPath (const std::initializer_list<size_t> &idxs,
 758                          size_t* index_of_error = NULL);
 759
 760     lldb::ValueObjectSP
 761     GetChildAtIndexPath (const std::vector<size_t> &idxs,
 762                          size_t* index_of_error = NULL);
 763
 764     lldb::ValueObjectSP
 765     GetChildAtIndexPath (const std::initializer_list< std::pair<size_t, bool> > &idxs,
 766                          size_t* index_of_error = NULL);
 767
 768     lldb::ValueObjectSP
 769     GetChildAtIndexPath (const std::vector< std::pair<size_t, bool> > &idxs,
 770                          size_t* index_of_error = NULL);
 771
 772     virtual lldb::ValueObjectSP
 773     GetChildMemberWithName (const ConstString &name, bool can_create);
 774
 775     virtual size_t
 776     GetIndexOfChildWithName (const ConstString &name);
 777
 778     size_t
 779     GetNumChildren ();
 780
 781     const Value &
 782     GetValue() const;
 783
 784     Value &
 785     GetValue();
 786
 787     virtual bool
 788     ResolveValue (Scalar &scalar);
 789
 790     virtual const char *
 791     GetLocationAsCString ();
 792
 793     const char *
 794     GetSummaryAsCString ();
 795
 796     bool
 797     GetSummaryAsCString (TypeSummaryImpl* summary_ptr,
 798                          std::string& destination);
 799
 800     const char *
 801     GetObjectDescription ();
 802
 803     bool
 804     HasSpecialPrintableRepresentation (ValueObjectRepresentationStyle val_obj_display,
 805                                        lldb::Format custom_format);
 806
 807     enum PrintableRepresentationSpecialCases
 808     {
 809         ePrintableRepresentationSpecialCasesDisable = 0,
 810         ePrintableRepresentationSpecialCasesAllow = 1,
 811         ePrintableRepresentationSpecialCasesOnly = 3
 812     };
 813
 814     bool
 815     DumpPrintableRepresentation (Stream& s,
 816                                  ValueObjectRepresentationStyle val_obj_display = eValueObjectRepresentationStyleSummary,
 817                                  lldb::Format custom_format = lldb::eFormatInvalid,
 818                                  PrintableRepresentationSpecialCases special = ePrintableRepresentationSpecialCasesAllow);
 819     bool
 820     GetValueIsValid () const;
 821
 822     bool
 823     GetValueDidChange ();
 824
 825     bool
 826     UpdateValueIfNeeded (bool update_format = true);
 827
 828     bool
 829     UpdateFormatsIfNeeded();
 830
 831     lldb::ValueObjectSP
 832     GetSP ()
 833     {
 834         return m_manager->GetSharedPointer(this);
 835     }
 836
 837     void
 838     SetName (const ConstString &name);
 839
 840     virtual lldb::addr_t
 841     GetAddressOf (bool scalar_is_load_address = true,
 842                   AddressType *address_type = NULL);
 843
 844     lldb::addr_t
 845     GetPointerValue (AddressType *address_type = NULL);
 846
 847     lldb::ValueObjectSP
 848     GetSyntheticChild (const ConstString &key) const;
 849
 850     lldb::ValueObjectSP
 851     GetSyntheticArrayMember (size_t index, bool can_create);
 852
 853     lldb::ValueObjectSP
 854     GetSyntheticArrayMemberFromPointer (size_t index, bool can_create);
 855
 856     lldb::ValueObjectSP
 857     GetSyntheticArrayMemberFromArray (size_t index, bool can_create);
 858
 859     lldb::ValueObjectSP
 860     GetSyntheticBitFieldChild (uint32_t from, uint32_t to, bool can_create);
 861
 862     lldb::ValueObjectSP
 863     GetSyntheticExpressionPathChild(const char* expression, bool can_create);
 864
 865     virtual lldb::ValueObjectSP
 866     GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create);
 867
 868     virtual lldb::ValueObjectSP
 869     GetDynamicValue (lldb::DynamicValueType valueType);
 870
 871     lldb::DynamicValueType
 872     GetDynamicValueType ();
 873
 874     virtual lldb::ValueObjectSP
 875     GetStaticValue ();
 876
 877     virtual lldb::ValueObjectSP
 878     GetNonSyntheticValue ();
 879
 880     lldb::ValueObjectSP
 881     GetSyntheticValue (bool use_synthetic = true);
 882
 883     virtual bool
 884     HasSyntheticValue();
 885
 886     virtual bool
 887     IsSynthetic() { return false; }
 888
 889     virtual lldb::ValueObjectSP
 890     CreateConstantValue (const ConstString &name);
 891
 892     virtual lldb::ValueObjectSP
 893     Dereference (Error &error);
 894
 895     virtual lldb::ValueObjectSP
 896     AddressOf (Error &error);
 897
 898     virtual lldb::addr_t
 899     GetLiveAddress()
 900     {
 901         return LLDB_INVALID_ADDRESS;
 902     }
 903
 904     virtual void
 905     SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS,
 906                    AddressType address_type = eAddressTypeLoad)
 907     {
 908     }
 909
 910     virtual lldb::ValueObjectSP
 911     Cast (const ClangASTType &clang_ast_type);
 912
 913     virtual lldb::ValueObjectSP
 914     CastPointerType (const char *name,
 915                      ClangASTType &ast_type);
 916
 917     virtual lldb::ValueObjectSP
 918     CastPointerType (const char *name,
 919                      lldb::TypeSP &type_sp);
 920
 921     // The backing bits of this value object were updated, clear any
 922     // descriptive string, so we know we have to refetch them
 923     virtual void
 924     ValueUpdated ()
 925     {
 926         ClearUserVisibleData(eClearUserVisibleDataItemsValue |
 927                              eClearUserVisibleDataItemsSummary |
 928                              eClearUserVisibleDataItemsDescription);
 929     }
 930
 931     virtual bool
 932     IsDynamic ()
 933     {
 934         return false;
 935     }
 936
 937     virtual SymbolContextScope *
 938     GetSymbolContextScope();
 939
 940     static void
 941     DumpValueObject (Stream &s,
 942                      ValueObject *valobj);
 943     static void
 944     DumpValueObject (Stream &s,
 945                      ValueObject *valobj,
 946                      const DumpValueObjectOptions& options);
 947
 948     static lldb::ValueObjectSP
 949     CreateValueObjectFromExpression (const char* name,
 950                                      const char* expression,
 951                                      const ExecutionContext& exe_ctx);
 952
 953     static lldb::ValueObjectSP
 954     CreateValueObjectFromAddress (const char* name,
 955                                   uint64_t address,
 956                                   const ExecutionContext& exe_ctx,
 957                                   ClangASTType type);
 958
 959     static lldb::ValueObjectSP
 960     CreateValueObjectFromData (const char* name,
 961                                DataExtractor& data,
 962                                const ExecutionContext& exe_ctx,
 963                                ClangASTType type);
 964
 965     static void
 966     LogValueObject (Log *log,
 967                     ValueObject *valobj);
 968
 969     static void
 970     LogValueObject (Log *log,
 971                     ValueObject *valobj,
 972                     const DumpValueObjectOptions& options);
 973
 974
 975     // returns true if this is a char* or a char[]
 976     // if it is a char* and check_pointer is true,
 977     // it also checks that the pointer is valid
 978     bool
 979     IsCStringContainer (bool check_pointer = false);
 980
 981     size_t
 982     ReadPointedString (Stream& s,
 983                        Error& error,
 984                        uint32_t max_length = 0,
 985                        bool honor_array = true,
 986                        lldb::Format item_format = lldb::eFormatCharArray);
 987
 988     virtual size_t
 989     GetPointeeData (DataExtractor& data,
 990                     uint32_t item_idx = 0,
 991                                         uint32_t item_count = 1);
 992
 993     virtual uint64_t
 994     GetData (DataExtractor& data);
 995
 996     virtual bool
 997     SetData (DataExtractor &data, Error &error);
 998
 999     bool
1000     GetIsConstant () const
1001     {
1002         return m_update_point.IsConstant();
1003     }
1004
1005     void
1006     SetIsConstant ()
1007     {
1008         m_update_point.SetIsConstant();
1009     }
1010
1011     lldb::Format
1012     GetFormat () const;
1013
1014     void
1015     SetFormat (lldb::Format format)
1016     {
1017         if (format != m_format)
1018             ClearUserVisibleData(eClearUserVisibleDataItemsValue);
1019         m_format = format;
1020     }
1021
1022     lldb::TypeSummaryImplSP
1023     GetSummaryFormat()
1024     {
1025         UpdateFormatsIfNeeded();
1026         return m_type_summary_sp;
1027     }
1028
1029     void
1030     SetSummaryFormat(lldb::TypeSummaryImplSP format)
1031     {
1032         m_type_summary_sp = format;
1033         ClearUserVisibleData(eClearUserVisibleDataItemsSummary);
1034     }
1035
1036     void
1037     SetValueFormat(lldb::TypeFormatImplSP format)
1038     {
1039         m_type_format_sp = format;
1040         ClearUserVisibleData(eClearUserVisibleDataItemsValue);
1041     }
1042
1043     lldb::TypeFormatImplSP
1044     GetValueFormat()
1045     {
1046         UpdateFormatsIfNeeded();
1047         return m_type_format_sp;
1048     }
1049
1050     void
1051     SetSyntheticChildren(const lldb::SyntheticChildrenSP &synth_sp)
1052     {
1053         if (synth_sp.get() == m_synthetic_children_sp.get())
1054             return;
1055         ClearUserVisibleData(eClearUserVisibleDataItemsSyntheticChildren);
1056         m_synthetic_children_sp = synth_sp;
1057     }
1058
1059     lldb::SyntheticChildrenSP
1060     GetSyntheticChildren()
1061     {
1062         UpdateFormatsIfNeeded();
1063         return m_synthetic_children_sp;
1064     }
1065
1066     // Use GetParent for display purposes, but if you want to tell the parent to update itself
1067     // then use m_parent.  The ValueObjectDynamicValue's parent is not the correct parent for
1068     // displaying, they are really siblings, so for display it needs to route through to its grandparent.
1069     virtual ValueObject *
1070     GetParent()
1071     {
1072         return m_parent;
1073     }
1074
1075     virtual const ValueObject *
1076     GetParent() const
1077     {
1078         return m_parent;
1079     }
1080
1081     ValueObject *
1082     GetNonBaseClassParent();
1083
1084     void
1085     SetAddressTypeOfChildren(AddressType at)
1086     {
1087         m_address_type_of_ptr_or_ref_children = at;
1088     }
1089
1090     AddressType
1091     GetAddressTypeOfChildren();
1092
1093     void
1094     SetHasCompleteType()
1095     {
1096         m_did_calculate_complete_objc_class_type = true;
1097     }
1098
1099     //------------------------------------------------------------------
1100     /// Find out if a ValueObject might have children.
1101     ///
1102     /// This call is much more efficient than CalculateNumChildren() as
1103     /// it doesn't need to complete the underlying type. This is designed
1104     /// to be used in a UI environment in order to detect if the
1105     /// disclosure triangle should be displayed or not.
1106     ///
1107     /// This function returns true for class, union, structure,
1108     /// pointers, references, arrays and more. Again, it does so without
1109     /// doing any expensive type completion.
1110     ///
1111     /// @return
1112     ///     Returns \b true if the ValueObject might have children, or \b
1113     ///     false otherwise.
1114     //------------------------------------------------------------------
1115     virtual bool
1116     MightHaveChildren();
1117
1118 protected:
1119     typedef ClusterManager<ValueObject> ValueObjectManager;
1120
1121     class ChildrenManager
1122     {
1123     public:
1124         ChildrenManager() :
1125             m_mutex(Mutex::eMutexTypeRecursive),
1126             m_children(),
1127             m_children_count(0)
1128         {}
1129
1130         bool
1131         HasChildAtIndex (size_t idx)
1132         {
1133             Mutex::Locker locker(m_mutex);
1134             ChildrenIterator iter = m_children.find(idx);
1135             ChildrenIterator end = m_children.end();
1136             return (iter != end);
1137         }
1138
1139         ValueObject*
1140         GetChildAtIndex (size_t idx)
1141         {
1142             Mutex::Locker locker(m_mutex);
1143             ChildrenIterator iter = m_children.find(idx);
1144             ChildrenIterator end = m_children.end();
1145             if (iter == end)
1146                 return NULL;
1147             else
1148                 return iter->second;
1149         }
1150
1151         void
1152         SetChildAtIndex (size_t idx, ValueObject* valobj)
1153         {
1154             ChildrenPair pair(idx,valobj); // we do not need to be mutex-protected to make a pair
1155             Mutex::Locker locker(m_mutex);
1156             m_children.insert(pair);
1157         }
1158
1159         void
1160         SetChildrenCount (size_t count)
1161         {
1162             m_children_count = count;
1163         }
1164
1165         size_t
1166         GetChildrenCount ()
1167         {
1168             return m_children_count;
1169         }
1170
1171         void
1172         Clear()
1173         {
1174             m_children_count = 0;
1175             Mutex::Locker locker(m_mutex);
1176             m_children.clear();
1177         }
1178
1179     private:
1180         typedef std::map<size_t, ValueObject*> ChildrenMap;
1181         typedef ChildrenMap::iterator ChildrenIterator;
1182         typedef ChildrenMap::value_type ChildrenPair;
1183         Mutex m_mutex;
1184         ChildrenMap m_children;
1185         size_t m_children_count;
1186     };
1187
1188     //------------------------------------------------------------------
1189     // Classes that inherit from ValueObject can see and modify these
1190     //------------------------------------------------------------------
1191     ValueObject  *      m_parent;       // The parent value object, or NULL if this has no parent
1192     ValueObject  *      m_root;         // The root of the hierarchy for this ValueObject (or NULL if never calculated)
1193     EvaluationPoint     m_update_point; // Stores both the stop id and the full context at which this value was last
1194                                         // updated.  When we are asked to update the value object, we check whether
1195                                         // the context & stop id are the same before updating.
1196     ConstString         m_name;         // The name of this object
1197     DataExtractor       m_data;         // A data extractor that can be used to extract the value.
1198     Value               m_value;
1199     Error               m_error;        // An error object that can describe any errors that occur when updating values.
1200     std::string         m_value_str;    // Cached value string that will get cleared if/when the value is updated.
1201     std::string         m_old_value_str;// Cached old value string from the last time the value was gotten
1202     std::string         m_location_str; // Cached location string that will get cleared if/when the value is updated.
1203     std::string         m_summary_str;  // Cached summary string that will get cleared if/when the value is updated.
1204     std::string         m_object_desc_str; // Cached result of the "object printer".  This differs from the summary
1205                                               // in that the summary is consed up by us, the object_desc_string is builtin.
1206
1207     ClangASTType        m_override_type;// If the type of the value object should be overridden, the type to impose.
1208
1209     ValueObjectManager *m_manager;      // This object is managed by the root object (any ValueObject that gets created
1210                                         // without a parent.)  The manager gets passed through all the generations of
1211                                         // dependent objects, and will keep the whole cluster of objects alive as long
1212                                         // as a shared pointer to any of them has been handed out.  Shared pointers to
1213                                         // value objects must always be made with the GetSP method.
1214
1215     ChildrenManager                      m_children;
1216     std::map<ConstString, ValueObject *> m_synthetic_children;
1217
1218     ValueObject*                         m_dynamic_value;
1219     ValueObject*                         m_synthetic_value;
1220     ValueObject*                         m_deref_valobj;
1221
1222     lldb::ValueObjectSP m_addr_of_valobj_sp; // We have to hold onto a shared pointer to this one because it is created
1223                                              // as an independent ValueObjectConstResult, which isn't managed by us.
1224
1225     lldb::Format                m_format;
1226     lldb::Format                m_last_format;
1227     uint32_t                    m_last_format_mgr_revision;
1228     lldb::TypeSummaryImplSP     m_type_summary_sp;
1229     lldb::TypeFormatImplSP      m_type_format_sp;
1230     lldb::SyntheticChildrenSP   m_synthetic_children_sp;
1231     ProcessModID                m_user_id_of_forced_summary;
1232     AddressType                 m_address_type_of_ptr_or_ref_children;
1233
1234     bool                m_value_is_valid:1,
1235                         m_value_did_change:1,
1236                         m_children_count_valid:1,
1237                         m_old_value_valid:1,
1238                         m_is_deref_of_parent:1,
1239                         m_is_array_item_for_pointer:1,
1240                         m_is_bitfield_for_scalar:1,
1241                         m_is_child_at_offset:1,
1242                         m_is_getting_summary:1,
1243                         m_did_calculate_complete_objc_class_type:1;
1244
1245     friend class ClangExpressionDeclMap;  // For GetValue
1246     friend class ClangExpressionVariable; // For SetName
1247     friend class Target;                  // For SetName
1248     friend class ValueObjectConstResultImpl;
1249
1250     //------------------------------------------------------------------
1251     // Constructors and Destructors
1252     //------------------------------------------------------------------
1253
1254     // Use the no-argument constructor to make a constant variable object (with no ExecutionContextScope.)
1255
1256     ValueObject();
1257
1258     // Use this constructor to create a "root variable object".  The ValueObject will be locked to this context
1259     // through-out its lifespan.
1260
1261     ValueObject (ExecutionContextScope *exe_scope,
1262                  AddressType child_ptr_or_ref_addr_type = eAddressTypeLoad);
1263
1264     // Use this constructor to create a ValueObject owned by another ValueObject.  It will inherit the ExecutionContext
1265     // of its parent.
1266
1267     ValueObject (ValueObject &parent);
1268
1269     ValueObjectManager *
1270     GetManager()
1271     {
1272         return m_manager;
1273     }
1274
1275     virtual bool
1276     UpdateValue () = 0;
1277
1278     virtual void
1279     CalculateDynamicValue (lldb::DynamicValueType use_dynamic);
1280
1281     virtual lldb::DynamicValueType
1282     GetDynamicValueTypeImpl ()
1283     {
1284         return lldb::eNoDynamicValues;
1285     }
1286
1287     virtual bool
1288     HasDynamicValueTypeInfo ()
1289     {
1290         return false;
1291     }
1292
1293     virtual void
1294     CalculateSyntheticValue (bool use_synthetic = true);
1295
1296     // Should only be called by ValueObject::GetChildAtIndex()
1297     // Returns a ValueObject managed by this ValueObject's manager.
1298     virtual ValueObject *
1299     CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index);
1300
1301     // Should only be called by ValueObject::GetNumChildren()
1302     virtual size_t
1303     CalculateNumChildren() = 0;
1304
1305     void
1306     SetNumChildren (size_t num_children);
1307
1308     void
1309     SetValueDidChange (bool value_changed);
1310
1311     void
1312     SetValueIsValid (bool valid);
1313
1314     void
1315     ClearUserVisibleData(uint32_t items = ValueObject::eClearUserVisibleDataItemsAllStrings);
1316
1317     void
1318     AddSyntheticChild (const ConstString &key,
1319                        ValueObject *valobj);
1320
1321     DataExtractor &
1322     GetDataExtractor ();
1323
1324     void
1325     ClearDynamicTypeInformation ();
1326
1327     //------------------------------------------------------------------
1328     // Sublasses must implement the functions below.
1329     //------------------------------------------------------------------
1330
1331     virtual ClangASTType
1332     GetClangTypeImpl () = 0;
1333
1334     const char *
1335     GetLocationAsCStringImpl (const Value& value,
1336                               const DataExtractor& data);
1337
1338 private:
1339     //------------------------------------------------------------------
1340     // For ValueObject only
1341     //------------------------------------------------------------------
1342
1343     virtual ClangASTType
1344     MaybeCalculateCompleteType ();
1345
1346     lldb::ValueObjectSP
1347     GetValueForExpressionPath_Impl(const char* expression_cstr,
1348                                    const char** first_unparsed,
1349                                    ExpressionPathScanEndReason* reason_to_stop,
1350                                    ExpressionPathEndResultType* final_value_type,
1351                                    const GetValueForExpressionPathOptions& options,
1352                                    ExpressionPathAftermath* final_task_on_target);
1353
1354     // this method will ONLY expand [] expressions into a VOList and return
1355     // the number of elements it added to the VOList
1356     // it will NOT loop through expanding the follow-up of the expression_cstr
1357     // for all objects in the list
1358     int
1359     ExpandArraySliceExpression(const char* expression_cstr,
1360                                const char** first_unparsed,
1361                                lldb::ValueObjectSP root,
1362                                lldb::ValueObjectListSP& list,
1363                                ExpressionPathScanEndReason* reason_to_stop,
1364                                ExpressionPathEndResultType* final_value_type,
1365                                const GetValueForExpressionPathOptions& options,
1366                                ExpressionPathAftermath* final_task_on_target);
1367
1368
1369     DISALLOW_COPY_AND_ASSIGN (ValueObject);
1370
1371 };
1372
1373 } // namespace lldb_private
1374
1375 #endif  // liblldb_ValueObject_h_