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