LLDB mainline
ValueObject.h
Go to the documentation of this file.
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"
14#include "lldb/Symbol/Type.h"
16#include "lldb/Target/Process.h"
20#include "lldb/Utility/Status.h"
21#include "lldb/Utility/UserID.h"
22#include "lldb/lldb-defines.h"
24#include "lldb/lldb-forward.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
43namespace lldb_private {
44class Declaration;
45class DumpValueObjectOptions;
46class EvaluateExpressionOptions;
47class ExecutionContextScope;
48class Log;
49class Scalar;
50class Stream;
51class SymbolContextScope;
52class TypeFormatImpl;
53class TypeSummaryImpl;
54class 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
106public:
110 };
111
121 };
122
124 /// Out of data to parse.
126 /// Child element not found.
128 /// (Synthetic) child element not found.
130 /// [] only allowed for arrays.
132 /// . used when -> should be used.
134 /// -> used when . should be used.
136 /// ObjC ivar expansion not allowed.
138 /// [] not allowed by options.
140 /// [] not valid on objects other than scalars, pointers or arrays.
142 /// [] is good for arrays, but I cannot parse it.
144 /// [] is good for bitfields, but I cannot parse after it.
146 /// Something is malformed in he expression.
148 /// Impossible to apply & operator.
150 /// Impossible to apply * operator.
152 /// [] was expanded into a VOList.
154 /// getting the synthetic children failed.
157 };
158
160 /// Anything but...
162 /// A bitfield.
164 /// A range [low-high].
166 /// A range [].
168 /// Several items in a VOList.
171 };
172
174 /// Just return it.
176 /// Dereference the target.
178 /// Take target's address.
180 };
181
194 };
195
198 None,
201 Both
202 };
203
208
210 bool dot = false, bool no_ivar = false, bool bitfield = true,
211 SyntheticChildrenTraversal synth_traverse =
214 m_allow_bitfields_syntax(bitfield),
215 m_synthetic_children_traversal(synth_traverse) {}
216
219 return *this;
220 }
221
224 return *this;
225 }
226
228 m_no_fragile_ivar = false;
229 return *this;
230 }
231
233 m_no_fragile_ivar = true;
234 return *this;
235 }
236
239 return *this;
240 }
241
244 return *this;
245 }
246
250 return *this;
251 }
252
254 static GetValueForExpressionPathOptions g_default_options;
255
256 return g_default_options;
257 }
258 };
259
261 public:
263
265 bool use_selected = false);
266
268
270
272 return m_exe_ctx_ref;
273 }
274
276 SetUpdated();
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
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.
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.
321 bool m_needs_update = true;
322 };
323
324 virtual ~ValueObject();
325
327
329
332 }
333
336 }
337
340 }
341
344 }
345
348 }
349
350 void SetNeedsUpdate();
351
353
354 // this vends a TypeImpl that is useful at the SB API layer
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.
366
368
370 return GetCompilerType().GetTypeName();
371 }
372
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
383
385
387
390 }
391
393
394 bool IsNilReference();
395
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,
411
413 llvm::StringRef expression,
414 ExpressionPathScanEndReason *reason_to_stop = nullptr,
415 ExpressionPathEndResultType *final_value_type = nullptr,
416 const GetValueForExpressionPathOptions &options =
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
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
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 virtual lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
483 bool can_create = true);
484
485 virtual size_t GetIndexOfChildWithName(llvm::StringRef name);
486
487 size_t GetNumChildren(uint32_t max = UINT32_MAX);
488
489 const Value &GetValue() const { return m_value; }
490
491 Value &GetValue() { return m_value; }
492
493 virtual bool ResolveValue(Scalar &scalar);
494
495 // return 'false' whenever you set the error, otherwise callers may assume
496 // true means everything is OK - this will break breakpoint conditions among
497 // potentially a few others
498 virtual bool IsLogicalTrue(Status &error);
499
500 virtual const char *GetLocationAsCString() {
502 }
503
504 const char *
506
507 bool
508 GetSummaryAsCString(TypeSummaryImpl *summary_ptr, std::string &destination,
510
511 bool GetSummaryAsCString(std::string &destination,
512 const TypeSummaryOptions &options);
513
514 bool GetSummaryAsCString(TypeSummaryImpl *summary_ptr,
515 std::string &destination,
516 const TypeSummaryOptions &options);
517
518 const char *GetObjectDescription();
519
521 ValueObjectRepresentationStyle val_obj_display,
522 lldb::Format custom_format);
523
525 eDisable = false,
526 eAllow = true
527 };
528
529 bool
531 ValueObjectRepresentationStyle val_obj_display =
533 lldb::Format custom_format = lldb::eFormatInvalid,
536 bool do_dump_error = true);
537 bool GetValueIsValid() const { return m_flags.m_value_is_valid; }
538
539 // If you call this on a newly created ValueObject, it will always return
540 // false.
542
543 bool UpdateValueIfNeeded(bool update_format = true);
544
546
548
549 /// Change the name of the current ValueObject. Should *not* be used from a
550 /// synthetic child provider as it would change the name of the non synthetic
551 /// child as well.
552 void SetName(ConstString name) { m_name = name; }
553
554 virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address = true,
555 AddressType *address_type = nullptr);
556
557 lldb::addr_t GetPointerValue(AddressType *address_type = nullptr);
558
560
561 lldb::ValueObjectSP GetSyntheticArrayMember(size_t index, bool can_create);
562
563 lldb::ValueObjectSP GetSyntheticBitFieldChild(uint32_t from, uint32_t to,
564 bool can_create);
565
567 bool can_create);
568
569 virtual lldb::ValueObjectSP
570 GetSyntheticChildAtOffset(uint32_t offset, const CompilerType &type,
571 bool can_create,
572 ConstString name_const_str = ConstString());
573
574 virtual lldb::ValueObjectSP
575 GetSyntheticBase(uint32_t offset, const CompilerType &type, bool can_create,
576 ConstString name_const_str = ConstString());
577
579
581
583
585
587
588 virtual bool HasSyntheticValue();
589
590 virtual bool IsSynthetic() { return false; }
591
594 bool synthValue);
595
597
599
600 /// Creates a copy of the ValueObject with a new name and setting the current
601 /// ValueObject as its parent. It should be used when we want to change the
602 /// name of a ValueObject without modifying the actual ValueObject itself
603 /// (e.g. sythetic child provider).
604 virtual lldb::ValueObjectSP Clone(ConstString new_name);
605
607
609
611 AddressType address_type = eAddressTypeLoad) {}
612
613 lldb::ValueObjectSP Cast(const CompilerType &compiler_type);
614
615 virtual lldb::ValueObjectSP DoCast(const CompilerType &compiler_type);
616
617 virtual lldb::ValueObjectSP CastPointerType(const char *name,
618 CompilerType &ast_type);
619
620 virtual lldb::ValueObjectSP CastPointerType(const char *name,
621 lldb::TypeSP &type_sp);
622
623 /// If this object represents a C++ class with a vtable, return an object
624 /// that represents the virtual function table. If the object isn't a class
625 /// with a vtable, return a valid ValueObject with the error set correctly.
627 // The backing bits of this value object were updated, clear any descriptive
628 // string, so we know we have to refetch them.
633 }
634
635 virtual bool IsDynamic() { return false; }
636
637 virtual bool DoesProvideSyntheticValue() { return false; }
638
641 }
642
643 virtual void SetSyntheticChildrenGenerated(bool b) {
645 }
646
648
649 void Dump(Stream &s);
650
651 void Dump(Stream &s, const DumpValueObjectOptions &options);
652
654 CreateValueObjectFromExpression(llvm::StringRef name,
655 llvm::StringRef expression,
656 const ExecutionContext &exe_ctx);
657
659 CreateValueObjectFromExpression(llvm::StringRef name,
660 llvm::StringRef expression,
661 const ExecutionContext &exe_ctx,
662 const EvaluateExpressionOptions &options);
663
665 CreateValueObjectFromAddress(llvm::StringRef name, uint64_t address,
666 const ExecutionContext &exe_ctx,
667 CompilerType type);
668
670 CreateValueObjectFromData(llvm::StringRef name, const DataExtractor &data,
671 const ExecutionContext &exe_ctx, CompilerType type);
672
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>
681 uint32_t max_length = 0, bool honor_array = true,
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
694 const bool accept_invalid_exe_ctx =
696 return m_update_point.NeedsUpdating(accept_invalid_exe_ctx);
697 }
698
700
701 lldb::Format GetFormat() const;
702
703 virtual void SetFormat(lldb::Format format) {
704 if (format != m_format)
706 m_format = format;
707 }
708
710
713 }
714
717 return m_type_summary_sp;
718 }
719
721 m_type_summary_sp = std::move(format);
723 }
724
726 m_type_format_sp = std::move(format);
728 }
729
732 return m_type_format_sp;
733 }
734
736 if (synth_sp.get() == m_synthetic_children_sp.get())
737 return;
739 m_synthetic_children_sp = synth_sp;
740 }
741
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
756
759 }
760
762
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
791protected:
793
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
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
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;
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.
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.
846 /// The name of this object.
848 /// A data extractor that can be used to extract the value.
851 /// An error object that can describe any errors that occur when updating
852 /// values.
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.
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.
875
877 std::map<ConstString, ValueObject *> m_synthetic_children;
878
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.
886
895
896 llvm::SmallVector<uint8_t, 16> m_value_checksum;
897
899
900 uint64_t m_language_flags = 0;
901
902 /// Unique identifier for every value object.
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 {
915 m_value_is_valid = false;
916 m_value_did_change = false;
918 m_old_value_valid = false;
919 m_is_deref_of_parent = false;
922 m_is_child_at_offset = false;
923 m_is_getting_summary = false;
926 }
928
929 friend class ValueObjectChild;
930 friend class ExpressionVariable; // For SetName
931 friend class Target; // For SetName
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.
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
945
946 virtual bool UpdateValue() = 0;
947
949 return eLazyBoolCalculate;
950 }
951
952 virtual void CalculateDynamicValue(lldb::DynamicValueType use_dynamic);
953
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
982
983 void AddSyntheticChild(ConstString key, ValueObject *valobj);
984
986
988
989 // Subclasses must implement the functions below.
990
992
993 const char *GetLocationAsCStringImpl(const Value &value,
994 const DataExtractor &data);
995
996 bool IsChecksumEmpty() { return m_value_checksum.empty(); }
997
999
1000protected:
1002
1003private:
1007 }
1008
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
static llvm::raw_ostream & error(Stream &strm)
std::shared_ptr< T > GetSharedPointer(T *desired_object)
Definition: SharedCluster.h:40
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
lldb::LanguageType GetMinimumLanguage()
bool IsArrayType(CompilerType *element_type=nullptr, uint64_t *size=nullptr, bool *is_incomplete=nullptr) const
ConstString GetTypeName(bool BaseOnly=false) const
bool IsIntegerType(bool &is_signed) const
uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr) const
bool IsPointerOrReferenceType(CompilerType *pointee_type=nullptr) const
bool IsPointerType(CompilerType *pointee_type=nullptr) const
A uniqued constant string class.
Definition: ConstString.h:40
An data extractor class.
Definition: DataExtractor.h:48
A class that describes the declaration location of a lldb object.
Definition: Declaration.h:24
Execution context objects refer to objects in the execution of the program that is being debugged.
lldb::StackFrameSP GetFrameSP() const
Get accessor that creates a strong reference from the weak frame reference contained in this object.
lldb::ThreadSP GetThreadSP() const
Get accessor that creates a strong reference from the weak thread reference contained in this object.
lldb::TargetSP GetTargetSP() const
Get accessor that creates a strong reference from the weak target reference contained in this object.
lldb::ProcessSP GetProcessSP() const
Get accessor that creates a strong reference from the weak process reference contained in this object...
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
bool IsValid() const
Definition: Process.h:265
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
"lldb/Symbol/SymbolContextScope.h" Inherit from this if your object is part of a symbol context and c...
A child of another ValueObject.
A class wrapping common implementation details for operations in ValueObjectConstResult ( & Child ) t...
A ValueObject that obtains its children from some source other than real information.
ValueObject * GetChildAtIndex(size_t idx)
Definition: ValueObject.h:803
void SetChildAtIndex(size_t idx, ValueObject *valobj)
Definition: ValueObject.h:809
std::map< size_t, ValueObject * > ChildrenMap
Definition: ValueObject.h:827
bool SyncWithProcessState(bool accept_invalid_exe_ctx)
void SetUpdateID(ProcessModID new_id)
Definition: ValueObject.h:284
const ExecutionContextRef & GetExecutionContextRef() const
Definition: ValueObject.h:271
bool NeedsUpdating(bool accept_invalid_exe_ctx)
Definition: ValueObject.h:290
AddressType m_address_type_of_ptr_or_ref_children
Definition: ValueObject.h:894
void SetValueIsValid(bool valid)
Definition: ValueObject.h:978
lldb::TypeFormatImplSP GetValueFormat()
Definition: ValueObject.h:730
EvaluationPoint m_update_point
Stores both the stop id and the full context at which this value was last updated.
Definition: ValueObject.h:845
lldb::TypeSummaryImplSP GetSummaryFormat()
Definition: ValueObject.h:715
llvm::SmallVector< uint8_t, 16 > m_value_checksum
Definition: ValueObject.h:896
virtual uint32_t GetBitfieldBitSize()
Definition: ValueObject.h:424
void ClearUserVisibleData(uint32_t items=ValueObject::eClearUserVisibleDataItemsAllStrings)
ValueObject * FollowParentChain(std::function< bool(ValueObject *)>)
Given a ValueObject, loop over itself and its parent, and its parent's parent, .
CompilerType m_override_type
If the type of the value object should be overridden, the type to impose.
Definition: ValueObject.h:866
virtual bool IsInScope()
Definition: ValueObject.h:420
lldb::ValueObjectSP Cast(const CompilerType &compiler_type)
const EvaluationPoint & GetUpdatePoint() const
Definition: ValueObject.h:326
void AddSyntheticChild(ConstString key, ValueObject *valobj)
virtual uint64_t GetData(DataExtractor &data, Status &error)
uint32_t m_last_format_mgr_revision
Definition: ValueObject.h:889
EvaluationPoint & GetUpdatePoint()
Definition: ValueObject.h:328
bool DumpPrintableRepresentation(Stream &s, ValueObjectRepresentationStyle val_obj_display=eValueObjectRepresentationStyleSummary, lldb::Format custom_format=lldb::eFormatInvalid, PrintableRepresentationSpecialCases special=PrintableRepresentationSpecialCases::eAllow, bool do_dump_error=true)
ValueObject * m_deref_valobj
Definition: ValueObject.h:881
virtual lldb::DynamicValueType GetDynamicValueTypeImpl()
Definition: ValueObject.h:954
const ValueObject & operator=(const ValueObject &)=delete
lldb::addr_t GetPointerValue(AddressType *address_type=nullptr)
virtual bool GetIsConstant() const
Definition: ValueObject.h:691
size_t GetNumChildren(uint32_t max=UINT32_MAX)
virtual bool MightHaveChildren()
Find out if a ValueObject might have children.
static lldb::ValueObjectSP CreateValueObjectFromExpression(llvm::StringRef name, llvm::StringRef expression, const ExecutionContext &exe_ctx)
virtual bool IsDereferenceOfParent()
Definition: ValueObject.h:402
CompilerType GetCompilerType()
Definition: ValueObject.h:352
virtual const ValueObject * GetParent() const
Definition: ValueObject.h:753
void SetValueFormat(lldb::TypeFormatImplSP format)
Definition: ValueObject.h:725
virtual lldb::addr_t GetLiveAddress()
Definition: ValueObject.h:608
virtual void CalculateSyntheticValue()
void SetPreferredDisplayLanguage(lldb::LanguageType lt)
Definition: ValueObject.h:711
struct lldb_private::ValueObject::Bitflags m_flags
ClusterManager< ValueObject > ValueObjectManager
Definition: ValueObject.h:792
virtual size_t CalculateNumChildren(uint32_t max=UINT32_MAX)=0
Should only be called by ValueObject::GetNumChildren().
std::string m_summary_str
Cached summary string that will get cleared if/when the value is updated.
Definition: ValueObject.h:861
virtual lldb::ValueObjectSP DoCast(const CompilerType &compiler_type)
lldb::TypeSummaryImplSP m_type_summary_sp
Definition: ValueObject.h:890
lldb::ValueObjectSP GetSP()
Definition: ValueObject.h:547
ChildrenManager m_children
Definition: ValueObject.h:876
virtual void SetLanguageFlags(uint64_t flags)
Definition: ValueObject.h:789
virtual lldb::ValueObjectSP CastPointerType(const char *name, CompilerType &ast_type)
Status m_error
An error object that can describe any errors that occur when updating values.
Definition: ValueObject.h:853
virtual size_t GetPointeeData(DataExtractor &data, uint32_t item_idx=0, uint32_t item_count=1)
lldb::ValueObjectSP GetSyntheticValue()
ValueObjectManager * m_manager
This object is managed by the root object (any ValueObject that gets created without a parent....
Definition: ValueObject.h:874
lldb::ValueObjectSP GetSyntheticBitFieldChild(uint32_t from, uint32_t to, bool can_create)
lldb::ProcessSP GetProcessSP() const
Definition: ValueObject.h:338
lldb::ValueObjectSP GetSyntheticChild(ConstString key) const
@ eExpressionPathScanEndReasonArrowInsteadOfDot
-> used when . should be used.
Definition: ValueObject.h:135
@ eExpressionPathScanEndReasonDereferencingFailed
Impossible to apply * operator.
Definition: ValueObject.h:151
@ eExpressionPathScanEndReasonNoSuchSyntheticChild
(Synthetic) child element not found.
Definition: ValueObject.h:129
@ eExpressionPathScanEndReasonNoSuchChild
Child element not found.
Definition: ValueObject.h:127
@ eExpressionPathScanEndReasonDotInsteadOfArrow
. used when -> should be used.
Definition: ValueObject.h:133
@ eExpressionPathScanEndReasonEndOfString
Out of data to parse.
Definition: ValueObject.h:125
@ eExpressionPathScanEndReasonBitfieldRangeOperatorMet
[] is good for bitfields, but I cannot parse after it.
Definition: ValueObject.h:145
@ eExpressionPathScanEndReasonRangeOperatorNotAllowed
[] not allowed by options.
Definition: ValueObject.h:139
@ eExpressionPathScanEndReasonEmptyRangeNotAllowed
[] only allowed for arrays.
Definition: ValueObject.h:131
@ eExpressionPathScanEndReasonRangeOperatorExpanded
[] was expanded into a VOList.
Definition: ValueObject.h:153
@ eExpressionPathScanEndReasonRangeOperatorInvalid
[] not valid on objects other than scalars, pointers or arrays.
Definition: ValueObject.h:141
@ eExpressionPathScanEndReasonUnexpectedSymbol
Something is malformed in he expression.
Definition: ValueObject.h:147
@ eExpressionPathScanEndReasonArrayRangeOperatorMet
[] is good for arrays, but I cannot parse it.
Definition: ValueObject.h:143
@ eExpressionPathScanEndReasonSyntheticValueMissing
getting the synthetic children failed.
Definition: ValueObject.h:155
@ eExpressionPathScanEndReasonTakingAddressFailed
Impossible to apply & operator.
Definition: ValueObject.h:149
@ eExpressionPathScanEndReasonFragileIVarNotAllowed
ObjC ivar expansion not allowed.
Definition: ValueObject.h:137
virtual bool UpdateValue()=0
lldb::Format GetFormat() const
virtual uint64_t GetLanguageFlags()
Definition: ValueObject.h:787
virtual lldb::VariableSP GetVariable()
Definition: ValueObject.h:783
@ eExpressionPathAftermathNothing
Just return it.
Definition: ValueObject.h:175
@ eExpressionPathAftermathDereference
Dereference the target.
Definition: ValueObject.h:177
@ eExpressionPathAftermathTakeAddress
Take target's address.
Definition: ValueObject.h:179
virtual void SetSyntheticChildrenGenerated(bool b)
Definition: ValueObject.h:643
virtual std::optional< uint64_t > GetByteSize()=0
virtual size_t GetIndexOfChildWithName(llvm::StringRef name)
lldb::user_id_t GetID() const
Returns a unique id for this ValueObject.
Definition: ValueObject.h:466
virtual void DoUpdateChildrenAddressType(ValueObject &valobj)
Definition: ValueObject.h:1001
ValueObject * GetNonBaseClassParent()
lldb::ValueObjectSP GetValueForExpressionPath(llvm::StringRef expression, ExpressionPathScanEndReason *reason_to_stop=nullptr, ExpressionPathEndResultType *final_value_type=nullptr, const GetValueForExpressionPathOptions &options=GetValueForExpressionPathOptions::DefaultOptions(), ExpressionPathAftermath *final_task_on_target=nullptr)
virtual lldb::ValueObjectSP GetSyntheticChildAtOffset(uint32_t offset, const CompilerType &type, bool can_create, ConstString name_const_str=ConstString())
virtual void CalculateDynamicValue(lldb::DynamicValueType use_dynamic)
DataExtractor m_data
A data extractor that can be used to extract the value.
Definition: ValueObject.h:849
virtual CompilerType GetCompilerTypeImpl()=0
virtual lldb::ValueObjectSP GetSyntheticBase(uint32_t offset, const CompilerType &type, bool can_create, ConstString name_const_str=ConstString())
virtual uint64_t GetValueAsUnsigned(uint64_t fail_value, bool *success=nullptr)
virtual bool IsDynamic()
Definition: ValueObject.h:635
virtual lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name, bool can_create=true)
virtual lldb::ValueType GetValueType() const =0
virtual void GetExpressionPath(Stream &s, GetExpressionPathFormat=eGetExpressionPathFormatDereferencePointers)
virtual bool HasSyntheticValue()
lldb::StackFrameSP GetFrameSP() const
Definition: ValueObject.h:346
lldb::ValueObjectSP GetChildAtNamePath(llvm::ArrayRef< llvm::StringRef > names)
void SetSummaryFormat(lldb::TypeSummaryImplSP format)
Definition: ValueObject.h:720
virtual bool IsRuntimeSupportValue()
virtual ConstString GetTypeName()
Definition: ValueObject.h:365
DataExtractor & GetDataExtractor()
virtual LazyBool CanUpdateWithInvalidExecutionContext()
Definition: ValueObject.h:948
static lldb::ValueObjectSP CreateValueObjectFromData(llvm::StringRef name, const DataExtractor &data, const ExecutionContext &exe_ctx, CompilerType type)
void SetValueDidChange(bool value_changed)
Definition: ValueObject.h:974
lldb::ThreadSP GetThreadSP() const
Definition: ValueObject.h:342
void SetNumChildren(size_t num_children)
ValueObjectManager * GetManager()
Definition: ValueObject.h:944
ValueObject * m_root
The root of the hierarchy for this ValueObject (or nullptr if never calculated).
Definition: ValueObject.h:841
bool GetValueIsValid() const
Definition: ValueObject.h:537
virtual lldb::ModuleSP GetModule()
Return the module associated with this value object in case the value is from an executable file and ...
virtual lldb::ValueObjectSP GetDynamicValue(lldb::DynamicValueType valueType)
virtual ConstString GetDisplayTypeName()
Definition: ValueObject.h:367
virtual lldb::ValueObjectSP AddressOf(Status &error)
lldb::DynamicValueType GetDynamicValueType()
lldb::SyntheticChildrenSP GetSyntheticChildren()
Definition: ValueObject.h:742
lldb::LanguageType m_preferred_display_language
Definition: ValueObject.h:898
uint32_t GetTypeInfo(CompilerType *pointee_or_element_compiler_type=nullptr)
Definition: ValueObject.h:378
lldb::LanguageType GetObjectRuntimeLanguage()
Definition: ValueObject.h:373
virtual lldb::ValueObjectSP CreateConstantValue(ConstString name)
virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address=true, AddressType *address_type=nullptr)
virtual bool IsLogicalTrue(Status &error)
lldb::Format m_last_format
Definition: ValueObject.h:888
virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create=true)
virtual SymbolContextScope * GetSymbolContextScope()
virtual bool HasDynamicValueTypeInfo()
Definition: ValueObject.h:958
ValueObject * m_synthetic_value
Definition: ValueObject.h:880
ValueObject * m_parent
The parent value object, or nullptr if this has no parent.
Definition: ValueObject.h:838
virtual bool IsBaseClass()
Definition: ValueObject.h:398
virtual bool GetDeclaration(Declaration &decl)
virtual lldb::ValueObjectSP Clone(ConstString new_name)
Creates a copy of the ValueObject with a new name and setting the current ValueObject as its parent.
lldb::ValueObjectSP GetChildAtIndexPath(llvm::ArrayRef< size_t > idxs, size_t *index_of_error=nullptr)
lldb::ValueObjectSP GetQualifiedRepresentationIfAvailable(lldb::DynamicValueType dynValue, bool synthValue)
virtual bool IsSyntheticChildrenGenerated()
Definition: ValueObject.h:639
virtual ValueObject * CreateChildAtIndex(size_t idx, bool synthetic_array_member, int32_t synthetic_index)
Should only be called by ValueObject::GetChildAtIndex().
lldb::ValueObjectSP m_addr_of_valobj_sp
We have to hold onto a shared pointer to this one because it is created as an independent ValueObject...
Definition: ValueObject.h:885
ValueObject(const ValueObject &)=delete
bool UpdateValueIfNeeded(bool update_format=true)
void SetName(ConstString name)
Change the name of the current ValueObject.
Definition: ValueObject.h:552
AddressType GetAddressTypeOfChildren()
const Status & GetError()
lldb::TypeFormatImplSP m_type_format_sp
Definition: ValueObject.h:891
lldb::TargetSP GetTargetSP() const
Definition: ValueObject.h:334
@ eExpressionPathEndResultTypePlain
Anything but...
Definition: ValueObject.h:161
@ eExpressionPathEndResultTypeBoundedRange
A range [low-high].
Definition: ValueObject.h:165
@ eExpressionPathEndResultTypeBitfield
A bitfield.
Definition: ValueObject.h:163
@ eExpressionPathEndResultTypeValueObjectList
Several items in a VOList.
Definition: ValueObject.h:169
@ eExpressionPathEndResultTypeUnboundedRange
A range [].
Definition: ValueObject.h:167
virtual lldb::ValueObjectSP Dereference(Status &error)
static lldb::ValueObjectSP CreateValueObjectFromAddress(llvm::StringRef name, uint64_t address, const ExecutionContext &exe_ctx, CompilerType type)
void SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType)
virtual const char * GetValueAsCString()
bool HasSpecialPrintableRepresentation(ValueObjectRepresentationStyle val_obj_display, lldb::Format custom_format)
virtual const char * GetLocationAsCString()
Definition: ValueObject.h:500
ConstString GetName() const
Definition: ValueObject.h:463
std::string m_location_str
Cached location string that will get cleared if/when the value is updated.
Definition: ValueObject.h:859
lldb::ValueObjectSP GetVTable()
If this object represents a C++ class with a vtable, return an object that represents the virtual fun...
virtual bool SetValueFromCString(const char *value_str, Status &error)
virtual lldb::ValueObjectSP GetStaticValue()
Definition: ValueObject.h:582
lldb::ValueObjectSP Persist()
std::string m_object_desc_str
Cached result of the "object printer".
Definition: ValueObject.h:864
virtual ValueObject * GetParent()
Definition: ValueObject.h:751
virtual ConstString GetQualifiedTypeName()
Definition: ValueObject.h:369
virtual bool DoesProvideSyntheticValue()
Definition: ValueObject.h:637
std::pair< size_t, bool > ReadPointedString(lldb::WritableDataBufferSP &buffer_sp, Status &error, uint32_t max_length=0, bool honor_array=true, lldb::Format item_format=lldb::eFormatCharArray)
virtual CompilerType MaybeCalculateCompleteType()
lldb::SyntheticChildrenSP m_synthetic_children_sp
Definition: ValueObject.h:892
const char * GetObjectDescription()
virtual uint32_t GetBitfieldBitOffset()
Definition: ValueObject.h:426
std::string m_old_value_str
Cached old value string from the last time the value was gotten.
Definition: ValueObject.h:857
virtual lldb::ValueObjectSP GetNonSyntheticValue()
Definition: ValueObject.h:584
lldb::ValueObjectSP GetSyntheticExpressionPathChild(const char *expression, bool can_create)
virtual bool SetData(DataExtractor &data, Status &error)
virtual int64_t GetValueAsSigned(int64_t fail_value, bool *success=nullptr)
const char * GetSummaryAsCString(lldb::LanguageType lang=lldb::eLanguageTypeUnknown)
@ eValueObjectRepresentationStyleLanguageSpecific
Definition: ValueObject.h:115
std::string m_value_str
Cached value string that will get cleared if/when the value is updated.
Definition: ValueObject.h:855
bool IsIntegerType(bool &is_signed)
Definition: ValueObject.h:404
lldb::ValueObjectSP GetSyntheticArrayMember(size_t index, bool can_create)
virtual bool ResolveValue(Scalar &scalar)
void SetSyntheticChildren(const lldb::SyntheticChildrenSP &synth_sp)
Definition: ValueObject.h:735
ConstString m_name
The name of this object.
Definition: ValueObject.h:847
const char * GetLocationAsCStringImpl(const Value &value, const DataExtractor &data)
virtual void SetFormat(lldb::Format format)
Definition: ValueObject.h:703
ValueObject * m_dynamic_value
Definition: ValueObject.h:879
ProcessModID m_user_id_of_forced_summary
Definition: ValueObject.h:893
virtual TypeImpl GetTypeImpl()
Definition: ValueObject.h:355
bool IsCStringContainer(bool check_pointer=false)
Returns true if this is a char* or a char[] if it is a char* and check_pointer is true,...
virtual bool IsSynthetic()
Definition: ValueObject.h:590
std::map< ConstString, ValueObject * > m_synthetic_children
Definition: ValueObject.h:877
const ExecutionContextRef & GetExecutionContextRef() const
Definition: ValueObject.h:330
virtual bool CanProvideValue()
UserID m_id
Unique identifier for every value object.
Definition: ValueObject.h:903
const Value & GetValue() const
Definition: ValueObject.h:489
virtual lldb::LanguageType GetPreferredDisplayLanguage()
virtual void SetLiveAddress(lldb::addr_t addr=LLDB_INVALID_ADDRESS, AddressType address_type=eAddressTypeLoad)
Definition: ValueObject.h:610
void SetAddressTypeOfChildren(AddressType at)
Definition: ValueObject.h:757
virtual lldb::offset_t GetByteOffset()
Definition: ValueObject.h:422
lldb::ValueObjectSP GetValueForExpressionPath_Impl(llvm::StringRef expression_cstr, ExpressionPathScanEndReason *reason_to_stop, ExpressionPathEndResultType *final_value_type, const GetValueForExpressionPathOptions &options, ExpressionPathAftermath *final_task_on_target)
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
@ eAddressTypeLoad
Address is an address as in the current target inferior process.
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:408
std::shared_ptr< lldb_private::TypeSummaryImpl > TypeSummaryImplSP
Definition: lldb-forward.h:459
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:434
std::shared_ptr< lldb_private::TypeFormatImpl > TypeFormatImplSP
Definition: lldb-forward.h:456
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition: lldb-forward.h:467
Format
Display format definitions.
@ eFormatCharArray
Print characters with no single quotes, used for character arrays that can contain non printable char...
uint64_t offset_t
Definition: lldb-types.h:83
LanguageType
Programming language type.
@ eLanguageTypeUnknown
Unknown or invalid language value.
std::shared_ptr< lldb_private::Type > TypeSP
Definition: lldb-forward.h:445
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:377
std::shared_ptr< lldb_private::Variable > VariableSP
Definition: lldb-forward.h:469
std::shared_ptr< lldb_private::SyntheticChildren > SyntheticChildrenSP
Definition: lldb-forward.h:429
uint64_t user_id_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
Definition: lldb-forward.h:325
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:432
@ eNoDynamicValues
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:361
A mix in class that contains a generic user ID.
Definition: UserID.h:31
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47
GetValueForExpressionPathOptions & DontAllowFragileIVar()
Definition: ValueObject.h:232
GetValueForExpressionPathOptions & SetSyntheticChildrenTraversal(SyntheticChildrenTraversal traverse)
Definition: ValueObject.h:248
GetValueForExpressionPathOptions & DoAllowFragileIVar()
Definition: ValueObject.h:227
GetValueForExpressionPathOptions(bool dot=false, bool no_ivar=false, bool bitfield=true, SyntheticChildrenTraversal synth_traverse=SyntheticChildrenTraversal::ToSynthetic)
Definition: ValueObject.h:209
static const GetValueForExpressionPathOptions DefaultOptions()
Definition: ValueObject.h:253
GetValueForExpressionPathOptions & DontCheckDotVsArrowSyntax()
Definition: ValueObject.h:222
GetValueForExpressionPathOptions & DontAllowBitfieldSyntax()
Definition: ValueObject.h:242
GetValueForExpressionPathOptions & DoCheckDotVsArrowSyntax()
Definition: ValueObject.h:217
GetValueForExpressionPathOptions & DoAllowBitfieldSyntax()
Definition: ValueObject.h:237