1 //===-- ValueObject.h -------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_CORE_VALUEOBJECT_H 10 #define LLDB_CORE_VALUEOBJECT_H 11 12 #include "lldb/Core/Value.h" 13 #include "lldb/Symbol/CompilerType.h" 14 #include "lldb/Symbol/Type.h" 15 #include "lldb/Target/ExecutionContext.h" 16 #include "lldb/Target/Process.h" 17 #include "lldb/Utility/ConstString.h" 18 #include "lldb/Utility/DataExtractor.h" 19 #include "lldb/Utility/SharedCluster.h" 20 #include "lldb/Utility/Status.h" 21 #include "lldb/Utility/UserID.h" 22 #include "lldb/lldb-defines.h" 23 #include "lldb/lldb-enumerations.h" 24 #include "lldb/lldb-forward.h" 25 #include "lldb/lldb-private-enumerations.h" 26 #include "lldb/lldb-types.h" 27 28 #include "llvm/ADT/ArrayRef.h" 29 #include "llvm/ADT/SmallVector.h" 30 #include "llvm/ADT/StringRef.h" 31 32 #include <functional> 33 #include <initializer_list> 34 #include <map> 35 #include <mutex> 36 #include <optional> 37 #include <string> 38 #include <utility> 39 40 #include <cstddef> 41 #include <cstdint> 42 43 namespace lldb_private { 44 class Declaration; 45 class DumpValueObjectOptions; 46 class EvaluateExpressionOptions; 47 class ExecutionContextScope; 48 class Log; 49 class Scalar; 50 class Stream; 51 class SymbolContextScope; 52 class TypeFormatImpl; 53 class TypeSummaryImpl; 54 class TypeSummaryOptions; 55 56 /// ValueObject: 57 /// 58 /// This abstract class provides an interface to a particular value, be it a 59 /// register, a local or global variable, 60 /// that is evaluated in some particular scope. The ValueObject also has the 61 /// capability of being the "child" of 62 /// some other variable object, and in turn of having children. 63 /// If a ValueObject is a root variable object - having no parent - then it must 64 /// be constructed with respect to some 65 /// particular ExecutionContextScope. If it is a child, it inherits the 66 /// ExecutionContextScope from its parent. 67 /// The ValueObject will update itself if necessary before fetching its value, 68 /// summary, object description, etc. 69 /// But it will always update itself in the ExecutionContextScope with which it 70 /// was originally created. 71 72 /// A brief note on life cycle management for ValueObjects. This is a little 73 /// tricky because a ValueObject can contain 74 /// various other ValueObjects - the Dynamic Value, its children, the 75 /// dereference value, etc. Any one of these can be 76 /// handed out as a shared pointer, but for that contained value object to be 77 /// valid, the root object and potentially other 78 /// of the value objects need to stay around. 79 /// We solve this problem by handing out shared pointers to the Value Object and 80 /// any of its dependents using a shared 81 /// ClusterManager. This treats each shared pointer handed out for the entire 82 /// cluster as a reference to the whole 83 /// cluster. The whole cluster will stay around until the last reference is 84 /// released. 85 /// 86 /// The ValueObject mostly handle this automatically, if a value object is made 87 /// with a Parent ValueObject, then it adds 88 /// itself to the ClusterManager of the parent. 89 90 /// It does mean that external to the ValueObjects we should only ever make 91 /// available ValueObjectSP's, never ValueObjects 92 /// or pointers to them. So all the "Root level" ValueObject derived 93 /// constructors should be private, and 94 /// should implement a Create function that new's up object and returns a Shared 95 /// Pointer that it gets from the GetSP() method. 96 /// 97 /// However, if you are making an derived ValueObject that will be contained in 98 /// a parent value object, you should just 99 /// hold onto a pointer to it internally, and by virtue of passing the parent 100 /// ValueObject into its constructor, it will 101 /// be added to the ClusterManager for the parent. Then if you ever hand out a 102 /// Shared Pointer to the contained ValueObject, 103 /// just do so by calling GetSP() on the contained object. 104 105 class ValueObject { 106 public: 107 enum GetExpressionPathFormat { 108 eGetExpressionPathFormatDereferencePointers = 1, 109 eGetExpressionPathFormatHonorPointers 110 }; 111 112 enum ValueObjectRepresentationStyle { 113 eValueObjectRepresentationStyleValue = 1, 114 eValueObjectRepresentationStyleSummary, 115 eValueObjectRepresentationStyleLanguageSpecific, 116 eValueObjectRepresentationStyleLocation, 117 eValueObjectRepresentationStyleChildrenCount, 118 eValueObjectRepresentationStyleType, 119 eValueObjectRepresentationStyleName, 120 eValueObjectRepresentationStyleExpressionPath 121 }; 122 123 enum ExpressionPathScanEndReason { 124 /// Out of data to parse. 125 eExpressionPathScanEndReasonEndOfString = 1, 126 /// Child element not found. 127 eExpressionPathScanEndReasonNoSuchChild, 128 /// (Synthetic) child element not found. 129 eExpressionPathScanEndReasonNoSuchSyntheticChild, 130 /// [] only allowed for arrays. 131 eExpressionPathScanEndReasonEmptyRangeNotAllowed, 132 /// . used when -> should be used. 133 eExpressionPathScanEndReasonDotInsteadOfArrow, 134 /// -> used when . should be used. 135 eExpressionPathScanEndReasonArrowInsteadOfDot, 136 /// ObjC ivar expansion not allowed. 137 eExpressionPathScanEndReasonFragileIVarNotAllowed, 138 /// [] not allowed by options. 139 eExpressionPathScanEndReasonRangeOperatorNotAllowed, 140 /// [] not valid on objects other than scalars, pointers or arrays. 141 eExpressionPathScanEndReasonRangeOperatorInvalid, 142 /// [] is good for arrays, but I cannot parse it. 143 eExpressionPathScanEndReasonArrayRangeOperatorMet, 144 /// [] is good for bitfields, but I cannot parse after it. 145 eExpressionPathScanEndReasonBitfieldRangeOperatorMet, 146 /// Something is malformed in he expression. 147 eExpressionPathScanEndReasonUnexpectedSymbol, 148 /// Impossible to apply & operator. 149 eExpressionPathScanEndReasonTakingAddressFailed, 150 /// Impossible to apply * operator. 151 eExpressionPathScanEndReasonDereferencingFailed, 152 /// [] was expanded into a VOList. 153 eExpressionPathScanEndReasonRangeOperatorExpanded, 154 /// getting the synthetic children failed. 155 eExpressionPathScanEndReasonSyntheticValueMissing, 156 eExpressionPathScanEndReasonUnknown = 0xFFFF 157 }; 158 159 enum ExpressionPathEndResultType { 160 /// Anything but... 161 eExpressionPathEndResultTypePlain = 1, 162 /// A bitfield. 163 eExpressionPathEndResultTypeBitfield, 164 /// A range [low-high]. 165 eExpressionPathEndResultTypeBoundedRange, 166 /// A range []. 167 eExpressionPathEndResultTypeUnboundedRange, 168 /// Several items in a VOList. 169 eExpressionPathEndResultTypeValueObjectList, 170 eExpressionPathEndResultTypeInvalid = 0xFFFF 171 }; 172 173 enum ExpressionPathAftermath { 174 /// Just return it. 175 eExpressionPathAftermathNothing = 1, 176 /// Dereference the target. 177 eExpressionPathAftermathDereference, 178 /// Take target's address. 179 eExpressionPathAftermathTakeAddress 180 }; 181 182 enum ClearUserVisibleDataItems { 183 eClearUserVisibleDataItemsNothing = 1u << 0, 184 eClearUserVisibleDataItemsValue = 1u << 1, 185 eClearUserVisibleDataItemsSummary = 1u << 2, 186 eClearUserVisibleDataItemsLocation = 1u << 3, 187 eClearUserVisibleDataItemsDescription = 1u << 4, 188 eClearUserVisibleDataItemsSyntheticChildren = 1u << 5, 189 eClearUserVisibleDataItemsAllStrings = 190 eClearUserVisibleDataItemsValue | eClearUserVisibleDataItemsSummary | 191 eClearUserVisibleDataItemsLocation | 192 eClearUserVisibleDataItemsDescription, 193 eClearUserVisibleDataItemsAll = 0xFFFF 194 }; 195 196 struct GetValueForExpressionPathOptions { 197 enum class SyntheticChildrenTraversal { 198 None, 199 ToSynthetic, 200 FromSynthetic, 201 Both 202 }; 203 204 bool m_check_dot_vs_arrow_syntax; 205 bool m_no_fragile_ivar; 206 bool m_allow_bitfields_syntax; 207 SyntheticChildrenTraversal m_synthetic_children_traversal; 208 209 GetValueForExpressionPathOptions( 210 bool dot = false, bool no_ivar = false, bool bitfield = true, 211 SyntheticChildrenTraversal synth_traverse = 212 SyntheticChildrenTraversal::ToSynthetic) 213 : m_check_dot_vs_arrow_syntax(dot), m_no_fragile_ivar(no_ivar), 214 m_allow_bitfields_syntax(bitfield), 215 m_synthetic_children_traversal(synth_traverse) {} 216 217 GetValueForExpressionPathOptions &DoCheckDotVsArrowSyntax() { 218 m_check_dot_vs_arrow_syntax = true; 219 return *this; 220 } 221 222 GetValueForExpressionPathOptions &DontCheckDotVsArrowSyntax() { 223 m_check_dot_vs_arrow_syntax = false; 224 return *this; 225 } 226 227 GetValueForExpressionPathOptions &DoAllowFragileIVar() { 228 m_no_fragile_ivar = false; 229 return *this; 230 } 231 232 GetValueForExpressionPathOptions &DontAllowFragileIVar() { 233 m_no_fragile_ivar = true; 234 return *this; 235 } 236 237 GetValueForExpressionPathOptions &DoAllowBitfieldSyntax() { 238 m_allow_bitfields_syntax = true; 239 return *this; 240 } 241 242 GetValueForExpressionPathOptions &DontAllowBitfieldSyntax() { 243 m_allow_bitfields_syntax = false; 244 return *this; 245 } 246 247 GetValueForExpressionPathOptions & 248 SetSyntheticChildrenTraversal(SyntheticChildrenTraversal traverse) { 249 m_synthetic_children_traversal = traverse; 250 return *this; 251 } 252 253 static const GetValueForExpressionPathOptions DefaultOptions() { 254 static GetValueForExpressionPathOptions g_default_options; 255 256 return g_default_options; 257 } 258 }; 259 260 class EvaluationPoint { 261 public: 262 EvaluationPoint(); 263 264 EvaluationPoint(ExecutionContextScope *exe_scope, 265 bool use_selected = false); 266 267 EvaluationPoint(const EvaluationPoint &rhs); 268 269 ~EvaluationPoint(); 270 271 const ExecutionContextRef &GetExecutionContextRef() const { 272 return m_exe_ctx_ref; 273 } 274 275 void SetIsConstant() { 276 SetUpdated(); 277 m_mod_id.SetInvalid(); 278 } 279 280 bool IsConstant() const { return !m_mod_id.IsValid(); } 281 282 ProcessModID GetModID() const { return m_mod_id; } 283 284 void SetUpdateID(ProcessModID new_id) { m_mod_id = new_id; } 285 286 void SetNeedsUpdate() { m_needs_update = true; } 287 288 void SetUpdated(); 289 290 bool NeedsUpdating(bool accept_invalid_exe_ctx) { 291 SyncWithProcessState(accept_invalid_exe_ctx); 292 return m_needs_update; 293 } 294 295 bool IsValid() { 296 const bool accept_invalid_exe_ctx = false; 297 if (!m_mod_id.IsValid()) 298 return false; 299 else if (SyncWithProcessState(accept_invalid_exe_ctx)) { 300 if (!m_mod_id.IsValid()) 301 return false; 302 } 303 return true; 304 } 305 306 void SetInvalid() { 307 // Use the stop id to mark us as invalid, leave the thread id and the 308 // stack id around for logging and history purposes. 309 m_mod_id.SetInvalid(); 310 311 // Can't update an invalid state. 312 m_needs_update = false; 313 } 314 315 private: 316 bool SyncWithProcessState(bool accept_invalid_exe_ctx); 317 318 ProcessModID m_mod_id; // This is the stop id when this ValueObject was last 319 // evaluated. 320 ExecutionContextRef m_exe_ctx_ref; 321 bool m_needs_update = true; 322 }; 323 324 virtual ~ValueObject(); 325 326 const EvaluationPoint &GetUpdatePoint() const { return m_update_point; } 327 328 EvaluationPoint &GetUpdatePoint() { return m_update_point; } 329 330 const ExecutionContextRef &GetExecutionContextRef() const { 331 return m_update_point.GetExecutionContextRef(); 332 } 333 334 lldb::TargetSP GetTargetSP() const { 335 return m_update_point.GetExecutionContextRef().GetTargetSP(); 336 } 337 338 lldb::ProcessSP GetProcessSP() const { 339 return m_update_point.GetExecutionContextRef().GetProcessSP(); 340 } 341 342 lldb::ThreadSP GetThreadSP() const { 343 return m_update_point.GetExecutionContextRef().GetThreadSP(); 344 } 345 346 lldb::StackFrameSP GetFrameSP() const { 347 return m_update_point.GetExecutionContextRef().GetFrameSP(); 348 } 349 350 void SetNeedsUpdate(); 351 352 CompilerType GetCompilerType() { return MaybeCalculateCompleteType(); } 353 354 // this vends a TypeImpl that is useful at the SB API layer 355 virtual TypeImpl GetTypeImpl() { return TypeImpl(GetCompilerType()); } 356 357 virtual bool CanProvideValue(); 358 359 // Subclasses must implement the functions below. 360 virtual std::optional<uint64_t> GetByteSize() = 0; 361 362 virtual lldb::ValueType GetValueType() const = 0; 363 364 // Subclasses can implement the functions below. 365 virtual ConstString GetTypeName() { return GetCompilerType().GetTypeName(); } 366 367 virtual ConstString GetDisplayTypeName() { return GetTypeName(); } 368 369 virtual ConstString GetQualifiedTypeName() { 370 return GetCompilerType().GetTypeName(); 371 } 372 373 lldb::LanguageType GetObjectRuntimeLanguage() { 374 return GetCompilerType().GetMinimumLanguage(); 375 } 376 377 uint32_t 378 GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) { 379 return GetCompilerType().GetTypeInfo(pointee_or_element_compiler_type); 380 } 381 382 bool IsPointerType() { return GetCompilerType().IsPointerType(); } 383 384 bool IsArrayType() { return GetCompilerType().IsArrayType(); } 385 386 bool IsScalarType() { return GetCompilerType().IsScalarType(); } 387 388 bool IsPointerOrReferenceType() { 389 return GetCompilerType().IsPointerOrReferenceType(); 390 } 391 392 bool IsPossibleDynamicType(); 393 394 bool IsNilReference(); 395 396 bool IsUninitializedReference(); 397 398 virtual bool IsBaseClass() { return false; } 399 400 bool IsBaseClass(uint32_t &depth); 401 402 virtual bool IsDereferenceOfParent() { return false; } 403 404 bool IsIntegerType(bool &is_signed) { 405 return GetCompilerType().IsIntegerType(is_signed); 406 } 407 408 virtual void GetExpressionPath( 409 Stream &s, 410 GetExpressionPathFormat = eGetExpressionPathFormatDereferencePointers); 411 412 lldb::ValueObjectSP GetValueForExpressionPath( 413 llvm::StringRef expression, 414 ExpressionPathScanEndReason *reason_to_stop = nullptr, 415 ExpressionPathEndResultType *final_value_type = nullptr, 416 const GetValueForExpressionPathOptions &options = 417 GetValueForExpressionPathOptions::DefaultOptions(), 418 ExpressionPathAftermath *final_task_on_target = nullptr); 419 420 virtual bool IsInScope() { return true; } 421 422 virtual lldb::offset_t GetByteOffset() { return 0; } 423 424 virtual uint32_t GetBitfieldBitSize() { return 0; } 425 426 virtual uint32_t GetBitfieldBitOffset() { return 0; } 427 428 bool IsBitfield() { 429 return (GetBitfieldBitSize() != 0) || (GetBitfieldBitOffset() != 0); 430 } 431 432 virtual const char *GetValueAsCString(); 433 434 virtual bool GetValueAsCString(const lldb_private::TypeFormatImpl &format, 435 std::string &destination); 436 437 bool GetValueAsCString(lldb::Format format, std::string &destination); 438 439 virtual uint64_t GetValueAsUnsigned(uint64_t fail_value, 440 bool *success = nullptr); 441 442 virtual int64_t GetValueAsSigned(int64_t fail_value, bool *success = nullptr); 443 444 virtual bool SetValueFromCString(const char *value_str, Status &error); 445 446 /// Return the module associated with this value object in case the value is 447 /// from an executable file and might have its data in sections of the file. 448 /// This can be used for variables. 449 virtual lldb::ModuleSP GetModule(); 450 451 ValueObject *GetRoot(); 452 453 /// Given a ValueObject, loop over itself and its parent, and its parent's 454 /// parent, .. until either the given callback returns false, or you end up at 455 /// a null pointer 456 ValueObject *FollowParentChain(std::function<bool(ValueObject *)>); 457 458 virtual bool GetDeclaration(Declaration &decl); 459 460 // The functions below should NOT be modified by subclasses 461 const Status &GetError(); 462 463 ConstString GetName() const { return m_name; } 464 465 /// Returns a unique id for this ValueObject. 466 lldb::user_id_t GetID() const { return m_id.GetID(); } 467 468 virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx, 469 bool can_create = true); 470 471 // this will always create the children if necessary 472 lldb::ValueObjectSP GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs, 473 size_t *index_of_error = nullptr); 474 475 lldb::ValueObjectSP 476 GetChildAtIndexPath(llvm::ArrayRef<std::pair<size_t, bool>> idxs, 477 size_t *index_of_error = nullptr); 478 479 // this will always create the children if necessary 480 lldb::ValueObjectSP GetChildAtNamePath(llvm::ArrayRef<llvm::StringRef> names); 481 482 lldb::ValueObjectSP 483 GetChildAtNamePath(llvm::ArrayRef<std::pair<ConstString, bool>> names, 484 ConstString *name_of_error = nullptr); 485 486 virtual lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name, 487 bool can_create = true); 488 489 virtual size_t GetIndexOfChildWithName(llvm::StringRef name); 490 491 size_t GetNumChildren(uint32_t max = UINT32_MAX); 492 493 const Value &GetValue() const { return m_value; } 494 495 Value &GetValue() { return m_value; } 496 497 virtual bool ResolveValue(Scalar &scalar); 498 499 // return 'false' whenever you set the error, otherwise callers may assume 500 // true means everything is OK - this will break breakpoint conditions among 501 // potentially a few others 502 virtual bool IsLogicalTrue(Status &error); 503 504 virtual const char *GetLocationAsCString() { 505 return GetLocationAsCStringImpl(m_value, m_data); 506 } 507 508 const char * 509 GetSummaryAsCString(lldb::LanguageType lang = lldb::eLanguageTypeUnknown); 510 511 bool 512 GetSummaryAsCString(TypeSummaryImpl *summary_ptr, std::string &destination, 513 lldb::LanguageType lang = lldb::eLanguageTypeUnknown); 514 515 bool GetSummaryAsCString(std::string &destination, 516 const TypeSummaryOptions &options); 517 518 bool GetSummaryAsCString(TypeSummaryImpl *summary_ptr, 519 std::string &destination, 520 const TypeSummaryOptions &options); 521 522 const char *GetObjectDescription(); 523 524 bool HasSpecialPrintableRepresentation( 525 ValueObjectRepresentationStyle val_obj_display, 526 lldb::Format custom_format); 527 528 enum class PrintableRepresentationSpecialCases : bool { 529 eDisable = false, 530 eAllow = true 531 }; 532 533 bool 534 DumpPrintableRepresentation(Stream &s, 535 ValueObjectRepresentationStyle val_obj_display = 536 eValueObjectRepresentationStyleSummary, 537 lldb::Format custom_format = lldb::eFormatInvalid, 538 PrintableRepresentationSpecialCases special = 539 PrintableRepresentationSpecialCases::eAllow, 540 bool do_dump_error = true); 541 bool GetValueIsValid() const { return m_flags.m_value_is_valid; } 542 543 // If you call this on a newly created ValueObject, it will always return 544 // false. 545 bool GetValueDidChange() { return m_flags.m_value_did_change; } 546 547 bool UpdateValueIfNeeded(bool update_format = true); 548 549 bool UpdateFormatsIfNeeded(); 550 551 lldb::ValueObjectSP GetSP() { return m_manager->GetSharedPointer(this); } 552 553 /// Change the name of the current ValueObject. Should *not* be used from a 554 /// synthetic child provider as it would change the name of the non synthetic 555 /// child as well. 556 void SetName(ConstString name) { m_name = name; } 557 558 virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address = true, 559 AddressType *address_type = nullptr); 560 561 lldb::addr_t GetPointerValue(AddressType *address_type = nullptr); 562 563 lldb::ValueObjectSP GetSyntheticChild(ConstString key) const; 564 565 lldb::ValueObjectSP GetSyntheticArrayMember(size_t index, bool can_create); 566 567 lldb::ValueObjectSP GetSyntheticBitFieldChild(uint32_t from, uint32_t to, 568 bool can_create); 569 570 lldb::ValueObjectSP GetSyntheticExpressionPathChild(const char *expression, 571 bool can_create); 572 573 virtual lldb::ValueObjectSP 574 GetSyntheticChildAtOffset(uint32_t offset, const CompilerType &type, 575 bool can_create, 576 ConstString name_const_str = ConstString()); 577 578 virtual lldb::ValueObjectSP 579 GetSyntheticBase(uint32_t offset, const CompilerType &type, bool can_create, 580 ConstString name_const_str = ConstString()); 581 582 virtual lldb::ValueObjectSP GetDynamicValue(lldb::DynamicValueType valueType); 583 584 lldb::DynamicValueType GetDynamicValueType(); 585 586 virtual lldb::ValueObjectSP GetStaticValue() { return GetSP(); } 587 588 virtual lldb::ValueObjectSP GetNonSyntheticValue() { return GetSP(); } 589 590 lldb::ValueObjectSP GetSyntheticValue(); 591 592 virtual bool HasSyntheticValue(); 593 594 virtual bool IsSynthetic() { return false; } 595 596 lldb::ValueObjectSP 597 GetQualifiedRepresentationIfAvailable(lldb::DynamicValueType dynValue, 598 bool synthValue); 599 600 virtual lldb::ValueObjectSP CreateConstantValue(ConstString name); 601 602 virtual lldb::ValueObjectSP Dereference(Status &error); 603 604 /// Creates a copy of the ValueObject with a new name and setting the current 605 /// ValueObject as its parent. It should be used when we want to change the 606 /// name of a ValueObject without modifying the actual ValueObject itself 607 /// (e.g. sythetic child provider). 608 virtual lldb::ValueObjectSP Clone(ConstString new_name); 609 610 virtual lldb::ValueObjectSP AddressOf(Status &error); 611 612 virtual lldb::addr_t GetLiveAddress() { return LLDB_INVALID_ADDRESS; } 613 614 virtual void SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS, 615 AddressType address_type = eAddressTypeLoad) {} 616 617 lldb::ValueObjectSP Cast(const CompilerType &compiler_type); 618 619 virtual lldb::ValueObjectSP DoCast(const CompilerType &compiler_type); 620 621 virtual lldb::ValueObjectSP CastPointerType(const char *name, 622 CompilerType &ast_type); 623 624 virtual lldb::ValueObjectSP CastPointerType(const char *name, 625 lldb::TypeSP &type_sp); 626 627 // The backing bits of this value object were updated, clear any descriptive 628 // string, so we know we have to refetch them. 629 void ValueUpdated() { 630 ClearUserVisibleData(eClearUserVisibleDataItemsValue | 631 eClearUserVisibleDataItemsSummary | 632 eClearUserVisibleDataItemsDescription); 633 } 634 635 virtual bool IsDynamic() { return false; } 636 637 virtual bool DoesProvideSyntheticValue() { return false; } 638 639 virtual bool IsSyntheticChildrenGenerated() { 640 return m_flags.m_is_synthetic_children_generated; 641 } 642 643 virtual void SetSyntheticChildrenGenerated(bool b) { 644 m_flags.m_is_synthetic_children_generated = b; 645 } 646 647 virtual SymbolContextScope *GetSymbolContextScope(); 648 649 void Dump(Stream &s); 650 651 void Dump(Stream &s, const DumpValueObjectOptions &options); 652 653 static lldb::ValueObjectSP 654 CreateValueObjectFromExpression(llvm::StringRef name, 655 llvm::StringRef expression, 656 const ExecutionContext &exe_ctx); 657 658 static lldb::ValueObjectSP 659 CreateValueObjectFromExpression(llvm::StringRef name, 660 llvm::StringRef expression, 661 const ExecutionContext &exe_ctx, 662 const EvaluateExpressionOptions &options); 663 664 static lldb::ValueObjectSP 665 CreateValueObjectFromAddress(llvm::StringRef name, uint64_t address, 666 const ExecutionContext &exe_ctx, 667 CompilerType type); 668 669 static lldb::ValueObjectSP 670 CreateValueObjectFromData(llvm::StringRef name, const DataExtractor &data, 671 const ExecutionContext &exe_ctx, CompilerType type); 672 673 lldb::ValueObjectSP Persist(); 674 675 /// Returns true if this is a char* or a char[] if it is a char* and 676 /// check_pointer is true, it also checks that the pointer is valid. 677 bool IsCStringContainer(bool check_pointer = false); 678 679 std::pair<size_t, bool> 680 ReadPointedString(lldb::WritableDataBufferSP &buffer_sp, Status &error, 681 uint32_t max_length = 0, bool honor_array = true, 682 lldb::Format item_format = lldb::eFormatCharArray); 683 684 virtual size_t GetPointeeData(DataExtractor &data, uint32_t item_idx = 0, 685 uint32_t item_count = 1); 686 687 virtual uint64_t GetData(DataExtractor &data, Status &error); 688 689 virtual bool SetData(DataExtractor &data, Status &error); 690 691 virtual bool GetIsConstant() const { return m_update_point.IsConstant(); } 692 693 bool NeedsUpdating() { 694 const bool accept_invalid_exe_ctx = 695 (CanUpdateWithInvalidExecutionContext() == eLazyBoolYes); 696 return m_update_point.NeedsUpdating(accept_invalid_exe_ctx); 697 } 698 699 void SetIsConstant() { m_update_point.SetIsConstant(); } 700 701 lldb::Format GetFormat() const; 702 703 virtual void SetFormat(lldb::Format format) { 704 if (format != m_format) 705 ClearUserVisibleData(eClearUserVisibleDataItemsValue); 706 m_format = format; 707 } 708 709 virtual lldb::LanguageType GetPreferredDisplayLanguage(); 710 711 void SetPreferredDisplayLanguage(lldb::LanguageType lt) { 712 m_preferred_display_language = lt; 713 } 714 715 lldb::TypeSummaryImplSP GetSummaryFormat() { 716 UpdateFormatsIfNeeded(); 717 return m_type_summary_sp; 718 } 719 720 void SetSummaryFormat(lldb::TypeSummaryImplSP format) { 721 m_type_summary_sp = std::move(format); 722 ClearUserVisibleData(eClearUserVisibleDataItemsSummary); 723 } 724 725 void SetValueFormat(lldb::TypeFormatImplSP format) { 726 m_type_format_sp = std::move(format); 727 ClearUserVisibleData(eClearUserVisibleDataItemsValue); 728 } 729 730 lldb::TypeFormatImplSP GetValueFormat() { 731 UpdateFormatsIfNeeded(); 732 return m_type_format_sp; 733 } 734 735 void SetSyntheticChildren(const lldb::SyntheticChildrenSP &synth_sp) { 736 if (synth_sp.get() == m_synthetic_children_sp.get()) 737 return; 738 ClearUserVisibleData(eClearUserVisibleDataItemsSyntheticChildren); 739 m_synthetic_children_sp = synth_sp; 740 } 741 742 lldb::SyntheticChildrenSP GetSyntheticChildren() { 743 UpdateFormatsIfNeeded(); 744 return m_synthetic_children_sp; 745 } 746 747 // Use GetParent for display purposes, but if you want to tell the parent to 748 // update itself then use m_parent. The ValueObjectDynamicValue's parent is 749 // not the correct parent for displaying, they are really siblings, so for 750 // display it needs to route through to its grandparent. 751 virtual ValueObject *GetParent() { return m_parent; } 752 753 virtual const ValueObject *GetParent() const { return m_parent; } 754 755 ValueObject *GetNonBaseClassParent(); 756 757 void SetAddressTypeOfChildren(AddressType at) { 758 m_address_type_of_ptr_or_ref_children = at; 759 } 760 761 AddressType GetAddressTypeOfChildren(); 762 763 void SetHasCompleteType() { 764 m_flags.m_did_calculate_complete_objc_class_type = true; 765 } 766 767 /// Find out if a ValueObject might have children. 768 /// 769 /// This call is much more efficient than CalculateNumChildren() as 770 /// it doesn't need to complete the underlying type. This is designed 771 /// to be used in a UI environment in order to detect if the 772 /// disclosure triangle should be displayed or not. 773 /// 774 /// This function returns true for class, union, structure, 775 /// pointers, references, arrays and more. Again, it does so without 776 /// doing any expensive type completion. 777 /// 778 /// \return 779 /// Returns \b true if the ValueObject might have children, or \b 780 /// false otherwise. 781 virtual bool MightHaveChildren(); 782 783 virtual lldb::VariableSP GetVariable() { return nullptr; } 784 785 virtual bool IsRuntimeSupportValue(); 786 787 virtual uint64_t GetLanguageFlags() { return m_language_flags; } 788 789 virtual void SetLanguageFlags(uint64_t flags) { m_language_flags = flags; } 790 791 protected: 792 typedef ClusterManager<ValueObject> ValueObjectManager; 793 794 class ChildrenManager { 795 public: 796 ChildrenManager() = default; 797 798 bool HasChildAtIndex(size_t idx) { 799 std::lock_guard<std::recursive_mutex> guard(m_mutex); 800 return (m_children.find(idx) != m_children.end()); 801 } 802 803 ValueObject *GetChildAtIndex(size_t idx) { 804 std::lock_guard<std::recursive_mutex> guard(m_mutex); 805 const auto iter = m_children.find(idx); 806 return ((iter == m_children.end()) ? nullptr : iter->second); 807 } 808 809 void SetChildAtIndex(size_t idx, ValueObject *valobj) { 810 // we do not need to be mutex-protected to make a pair 811 ChildrenPair pair(idx, valobj); 812 std::lock_guard<std::recursive_mutex> guard(m_mutex); 813 m_children.insert(pair); 814 } 815 816 void SetChildrenCount(size_t count) { Clear(count); } 817 818 size_t GetChildrenCount() { return m_children_count; } 819 820 void Clear(size_t new_count = 0) { 821 std::lock_guard<std::recursive_mutex> guard(m_mutex); 822 m_children_count = new_count; 823 m_children.clear(); 824 } 825 826 private: 827 typedef std::map<size_t, ValueObject *> ChildrenMap; 828 typedef ChildrenMap::iterator ChildrenIterator; 829 typedef ChildrenMap::value_type ChildrenPair; 830 std::recursive_mutex m_mutex; 831 ChildrenMap m_children; 832 size_t m_children_count = 0; 833 }; 834 835 // Classes that inherit from ValueObject can see and modify these 836 837 /// The parent value object, or nullptr if this has no parent. 838 ValueObject *m_parent = nullptr; 839 /// The root of the hierarchy for this ValueObject (or nullptr if never 840 /// calculated). 841 ValueObject *m_root = nullptr; 842 /// Stores both the stop id and the full context at which this value was last 843 /// updated. When we are asked to update the value object, we check whether 844 /// the context & stop id are the same before updating. 845 EvaluationPoint m_update_point; 846 /// The name of this object. 847 ConstString m_name; 848 /// A data extractor that can be used to extract the value. 849 DataExtractor m_data; 850 Value m_value; 851 /// An error object that can describe any errors that occur when updating 852 /// values. 853 Status m_error; 854 /// Cached value string that will get cleared if/when the value is updated. 855 std::string m_value_str; 856 /// Cached old value string from the last time the value was gotten 857 std::string m_old_value_str; 858 /// Cached location string that will get cleared if/when the value is updated. 859 std::string m_location_str; 860 /// Cached summary string that will get cleared if/when the value is updated. 861 std::string m_summary_str; 862 /// Cached result of the "object printer". This differs from the summary 863 /// in that the summary is consed up by us, the object_desc_string is builtin. 864 std::string m_object_desc_str; 865 /// If the type of the value object should be overridden, the type to impose. 866 CompilerType m_override_type; 867 868 /// This object is managed by the root object (any ValueObject that gets 869 /// created without a parent.) The manager gets passed through all the 870 /// generations of dependent objects, and will keep the whole cluster of 871 /// objects alive as long as a shared pointer to any of them has been handed 872 /// out. Shared pointers to value objects must always be made with the GetSP 873 /// method. 874 ValueObjectManager *m_manager = nullptr; 875 876 ChildrenManager m_children; 877 std::map<ConstString, ValueObject *> m_synthetic_children; 878 879 ValueObject *m_dynamic_value = nullptr; 880 ValueObject *m_synthetic_value = nullptr; 881 ValueObject *m_deref_valobj = nullptr; 882 883 /// We have to hold onto a shared pointer to this one because it is created 884 /// as an independent ValueObjectConstResult, which isn't managed by us. 885 lldb::ValueObjectSP m_addr_of_valobj_sp; 886 887 lldb::Format m_format = lldb::eFormatDefault; 888 lldb::Format m_last_format = lldb::eFormatDefault; 889 uint32_t m_last_format_mgr_revision = 0; 890 lldb::TypeSummaryImplSP m_type_summary_sp; 891 lldb::TypeFormatImplSP m_type_format_sp; 892 lldb::SyntheticChildrenSP m_synthetic_children_sp; 893 ProcessModID m_user_id_of_forced_summary; 894 AddressType m_address_type_of_ptr_or_ref_children = eAddressTypeInvalid; 895 896 llvm::SmallVector<uint8_t, 16> m_value_checksum; 897 898 lldb::LanguageType m_preferred_display_language = lldb::eLanguageTypeUnknown; 899 900 uint64_t m_language_flags = 0; 901 902 /// Unique identifier for every value object. 903 UserID m_id; 904 905 // Utility class for initializing all bitfields in ValueObject's constructors. 906 // FIXME: This could be done via default initializers once we have C++20. 907 struct Bitflags { 908 bool m_value_is_valid : 1, m_value_did_change : 1, 909 m_children_count_valid : 1, m_old_value_valid : 1, 910 m_is_deref_of_parent : 1, m_is_array_item_for_pointer : 1, 911 m_is_bitfield_for_scalar : 1, m_is_child_at_offset : 1, 912 m_is_getting_summary : 1, m_did_calculate_complete_objc_class_type : 1, 913 m_is_synthetic_children_generated : 1; 914 Bitflags() { 915 m_value_is_valid = false; 916 m_value_did_change = false; 917 m_children_count_valid = false; 918 m_old_value_valid = false; 919 m_is_deref_of_parent = false; 920 m_is_array_item_for_pointer = false; 921 m_is_bitfield_for_scalar = false; 922 m_is_child_at_offset = false; 923 m_is_getting_summary = false; 924 m_did_calculate_complete_objc_class_type = false; 925 m_is_synthetic_children_generated = false; 926 } 927 } m_flags; 928 929 friend class ValueObjectChild; 930 friend class ExpressionVariable; // For SetName 931 friend class Target; // For SetName 932 friend class ValueObjectConstResultImpl; 933 friend class ValueObjectSynthetic; // For ClearUserVisibleData 934 935 /// Use this constructor to create a "root variable object". The ValueObject 936 /// will be locked to this context through-out its lifespan. 937 ValueObject(ExecutionContextScope *exe_scope, ValueObjectManager &manager, 938 AddressType child_ptr_or_ref_addr_type = eAddressTypeLoad); 939 940 /// Use this constructor to create a ValueObject owned by another ValueObject. 941 /// It will inherit the ExecutionContext of its parent. 942 ValueObject(ValueObject &parent); 943 944 ValueObjectManager *GetManager() { return m_manager; } 945 946 virtual bool UpdateValue() = 0; 947 948 virtual LazyBool CanUpdateWithInvalidExecutionContext() { 949 return eLazyBoolCalculate; 950 } 951 952 virtual void CalculateDynamicValue(lldb::DynamicValueType use_dynamic); 953 954 virtual lldb::DynamicValueType GetDynamicValueTypeImpl() { 955 return lldb::eNoDynamicValues; 956 } 957 958 virtual bool HasDynamicValueTypeInfo() { return false; } 959 960 virtual void CalculateSyntheticValue(); 961 962 /// Should only be called by ValueObject::GetChildAtIndex(). 963 /// 964 /// \return A ValueObject managed by this ValueObject's manager. 965 virtual ValueObject *CreateChildAtIndex(size_t idx, 966 bool synthetic_array_member, 967 int32_t synthetic_index); 968 969 /// Should only be called by ValueObject::GetNumChildren(). 970 virtual size_t CalculateNumChildren(uint32_t max = UINT32_MAX) = 0; 971 972 void SetNumChildren(size_t num_children); 973 974 void SetValueDidChange(bool value_changed) { 975 m_flags.m_value_did_change = value_changed; 976 } 977 978 void SetValueIsValid(bool valid) { m_flags.m_value_is_valid = valid; } 979 980 void ClearUserVisibleData( 981 uint32_t items = ValueObject::eClearUserVisibleDataItemsAllStrings); 982 983 void AddSyntheticChild(ConstString key, ValueObject *valobj); 984 985 DataExtractor &GetDataExtractor(); 986 987 void ClearDynamicTypeInformation(); 988 989 // Subclasses must implement the functions below. 990 991 virtual CompilerType GetCompilerTypeImpl() = 0; 992 993 const char *GetLocationAsCStringImpl(const Value &value, 994 const DataExtractor &data); 995 996 bool IsChecksumEmpty() { return m_value_checksum.empty(); } 997 998 void SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType); 999 1000 protected: 1001 virtual void DoUpdateChildrenAddressType(ValueObject &valobj){}; 1002 1003 private: 1004 virtual CompilerType MaybeCalculateCompleteType(); 1005 void UpdateChildrenAddressType() { 1006 GetRoot()->DoUpdateChildrenAddressType(*this); 1007 } 1008 1009 lldb::ValueObjectSP GetValueForExpressionPath_Impl( 1010 llvm::StringRef expression_cstr, 1011 ExpressionPathScanEndReason *reason_to_stop, 1012 ExpressionPathEndResultType *final_value_type, 1013 const GetValueForExpressionPathOptions &options, 1014 ExpressionPathAftermath *final_task_on_target); 1015 1016 ValueObject(const ValueObject &) = delete; 1017 const ValueObject &operator=(const ValueObject &) = delete; 1018 }; 1019 1020 } // namespace lldb_private 1021 1022 #endif // LLDB_CORE_VALUEOBJECT_H 1023