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)
m_check_dot_vs_arrow_syntaxGetValueForExpressionPathOptions213         : 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 
DoCheckDotVsArrowSyntaxGetValueForExpressionPathOptions217     GetValueForExpressionPathOptions &DoCheckDotVsArrowSyntax() {
218       m_check_dot_vs_arrow_syntax = true;
219       return *this;
220     }
221 
DontCheckDotVsArrowSyntaxGetValueForExpressionPathOptions222     GetValueForExpressionPathOptions &DontCheckDotVsArrowSyntax() {
223       m_check_dot_vs_arrow_syntax = false;
224       return *this;
225     }
226 
DoAllowFragileIVarGetValueForExpressionPathOptions227     GetValueForExpressionPathOptions &DoAllowFragileIVar() {
228       m_no_fragile_ivar = false;
229       return *this;
230     }
231 
DontAllowFragileIVarGetValueForExpressionPathOptions232     GetValueForExpressionPathOptions &DontAllowFragileIVar() {
233       m_no_fragile_ivar = true;
234       return *this;
235     }
236 
DoAllowBitfieldSyntaxGetValueForExpressionPathOptions237     GetValueForExpressionPathOptions &DoAllowBitfieldSyntax() {
238       m_allow_bitfields_syntax = true;
239       return *this;
240     }
241 
DontAllowBitfieldSyntaxGetValueForExpressionPathOptions242     GetValueForExpressionPathOptions &DontAllowBitfieldSyntax() {
243       m_allow_bitfields_syntax = false;
244       return *this;
245     }
246 
247     GetValueForExpressionPathOptions &
SetSyntheticChildrenTraversalGetValueForExpressionPathOptions248     SetSyntheticChildrenTraversal(SyntheticChildrenTraversal traverse) {
249       m_synthetic_children_traversal = traverse;
250       return *this;
251     }
252 
DefaultOptionsGetValueForExpressionPathOptions253     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 
GetExecutionContextRef()271     const ExecutionContextRef &GetExecutionContextRef() const {
272       return m_exe_ctx_ref;
273     }
274 
SetIsConstant()275     void SetIsConstant() {
276       SetUpdated();
277       m_mod_id.SetInvalid();
278     }
279 
IsConstant()280     bool IsConstant() const { return !m_mod_id.IsValid(); }
281 
GetModID()282     ProcessModID GetModID() const { return m_mod_id; }
283 
SetUpdateID(ProcessModID new_id)284     void SetUpdateID(ProcessModID new_id) { m_mod_id = new_id; }
285 
SetNeedsUpdate()286     void SetNeedsUpdate() { m_needs_update = true; }
287 
288     void SetUpdated();
289 
NeedsUpdating(bool accept_invalid_exe_ctx)290     bool NeedsUpdating(bool accept_invalid_exe_ctx) {
291       SyncWithProcessState(accept_invalid_exe_ctx);
292       return m_needs_update;
293     }
294 
IsValid()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 
SetInvalid()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 
GetUpdatePoint()326   const EvaluationPoint &GetUpdatePoint() const { return m_update_point; }
327 
GetUpdatePoint()328   EvaluationPoint &GetUpdatePoint() { return m_update_point; }
329 
GetExecutionContextRef()330   const ExecutionContextRef &GetExecutionContextRef() const {
331     return m_update_point.GetExecutionContextRef();
332   }
333 
GetTargetSP()334   lldb::TargetSP GetTargetSP() const {
335     return m_update_point.GetExecutionContextRef().GetTargetSP();
336   }
337 
GetProcessSP()338   lldb::ProcessSP GetProcessSP() const {
339     return m_update_point.GetExecutionContextRef().GetProcessSP();
340   }
341 
GetThreadSP()342   lldb::ThreadSP GetThreadSP() const {
343     return m_update_point.GetExecutionContextRef().GetThreadSP();
344   }
345 
GetFrameSP()346   lldb::StackFrameSP GetFrameSP() const {
347     return m_update_point.GetExecutionContextRef().GetFrameSP();
348   }
349 
350   void SetNeedsUpdate();
351 
GetCompilerType()352   CompilerType GetCompilerType() { return MaybeCalculateCompleteType(); }
353 
354   // this vends a TypeImpl that is useful at the SB API layer
GetTypeImpl()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.
GetTypeName()365   virtual ConstString GetTypeName() { return GetCompilerType().GetTypeName(); }
366 
GetDisplayTypeName()367   virtual ConstString GetDisplayTypeName() { return GetTypeName(); }
368 
GetQualifiedTypeName()369   virtual ConstString GetQualifiedTypeName() {
370     return GetCompilerType().GetTypeName();
371   }
372 
GetObjectRuntimeLanguage()373   virtual lldb::LanguageType GetObjectRuntimeLanguage() {
374     return GetCompilerType().GetMinimumLanguage();
375   }
376 
377   virtual uint32_t
378   GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) {
379     return GetCompilerType().GetTypeInfo(pointee_or_element_compiler_type);
380   }
381 
IsPointerType()382   virtual bool IsPointerType() { return GetCompilerType().IsPointerType(); }
383 
IsArrayType()384   virtual bool IsArrayType() { return GetCompilerType().IsArrayType(); }
385 
IsScalarType()386   virtual bool IsScalarType() { return GetCompilerType().IsScalarType(); }
387 
IsPointerOrReferenceType()388   virtual bool IsPointerOrReferenceType() {
389     return GetCompilerType().IsPointerOrReferenceType();
390   }
391 
392   virtual bool IsPossibleDynamicType();
393 
394   bool IsNilReference();
395 
396   bool IsUninitializedReference();
397 
IsBaseClass()398   virtual bool IsBaseClass() { return false; }
399 
400   bool IsBaseClass(uint32_t &depth);
401 
IsDereferenceOfParent()402   virtual bool IsDereferenceOfParent() { return false; }
403 
IsIntegerType(bool & is_signed)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 
IsInScope()420   virtual bool IsInScope() { return true; }
421 
GetByteOffset()422   virtual lldb::offset_t GetByteOffset() { return 0; }
423 
GetBitfieldBitSize()424   virtual uint32_t GetBitfieldBitSize() { return 0; }
425 
GetBitfieldBitOffset()426   virtual uint32_t GetBitfieldBitOffset() { return 0; }
427 
IsBitfield()428   bool IsBitfield() {
429     return (GetBitfieldBitSize() != 0) || (GetBitfieldBitOffset() != 0);
430   }
431 
IsArrayItemForPointer()432   virtual bool IsArrayItemForPointer() {
433     return m_flags.m_is_array_item_for_pointer;
434   }
435 
436   virtual const char *GetValueAsCString();
437 
438   virtual bool GetValueAsCString(const lldb_private::TypeFormatImpl &format,
439                                  std::string &destination);
440 
441   bool GetValueAsCString(lldb::Format format, std::string &destination);
442 
443   virtual uint64_t GetValueAsUnsigned(uint64_t fail_value,
444                                       bool *success = nullptr);
445 
446   virtual int64_t GetValueAsSigned(int64_t fail_value, bool *success = nullptr);
447 
448   virtual bool SetValueFromCString(const char *value_str, Status &error);
449 
450   /// Return the module associated with this value object in case the value is
451   /// from an executable file and might have its data in sections of the file.
452   /// This can be used for variables.
453   virtual lldb::ModuleSP GetModule();
454 
455   ValueObject *GetRoot();
456 
457   /// Given a ValueObject, loop over itself and its parent, and its parent's
458   /// parent, .. until either the given callback returns false, or you end up at
459   /// a null pointer
460   ValueObject *FollowParentChain(std::function<bool(ValueObject *)>);
461 
462   virtual bool GetDeclaration(Declaration &decl);
463 
464   // The functions below should NOT be modified by subclasses
465   const Status &GetError();
466 
GetName()467   ConstString GetName() const { return m_name; }
468 
469   /// Returns a unique id for this ValueObject.
GetID()470   lldb::user_id_t GetID() const { return m_id.GetID(); }
471 
472   virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create);
473 
474   // this will always create the children if necessary
475   lldb::ValueObjectSP GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs,
476                                           size_t *index_of_error = nullptr);
477 
478   lldb::ValueObjectSP
479   GetChildAtIndexPath(llvm::ArrayRef<std::pair<size_t, bool>> idxs,
480                       size_t *index_of_error = nullptr);
481 
482   // this will always create the children if necessary
483   lldb::ValueObjectSP GetChildAtNamePath(llvm::ArrayRef<ConstString> names,
484                                          ConstString *name_of_error = nullptr);
485 
486   lldb::ValueObjectSP
487   GetChildAtNamePath(llvm::ArrayRef<std::pair<ConstString, bool>> names,
488                      ConstString *name_of_error = nullptr);
489 
490   virtual lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
491                                                      bool can_create);
492 
493   virtual size_t GetIndexOfChildWithName(ConstString name);
494 
495   size_t GetNumChildren(uint32_t max = UINT32_MAX);
496 
GetValue()497   const Value &GetValue() const { return m_value; }
498 
GetValue()499   Value &GetValue() { return m_value; }
500 
501   virtual bool ResolveValue(Scalar &scalar);
502 
503   // return 'false' whenever you set the error, otherwise callers may assume
504   // true means everything is OK - this will break breakpoint conditions among
505   // potentially a few others
506   virtual bool IsLogicalTrue(Status &error);
507 
GetLocationAsCString()508   virtual const char *GetLocationAsCString() {
509     return GetLocationAsCStringImpl(m_value, m_data);
510   }
511 
512   const char *
513   GetSummaryAsCString(lldb::LanguageType lang = lldb::eLanguageTypeUnknown);
514 
515   bool
516   GetSummaryAsCString(TypeSummaryImpl *summary_ptr, std::string &destination,
517                       lldb::LanguageType lang = lldb::eLanguageTypeUnknown);
518 
519   bool GetSummaryAsCString(std::string &destination,
520                            const TypeSummaryOptions &options);
521 
522   bool GetSummaryAsCString(TypeSummaryImpl *summary_ptr,
523                            std::string &destination,
524                            const TypeSummaryOptions &options);
525 
526   const char *GetObjectDescription();
527 
528   bool HasSpecialPrintableRepresentation(
529       ValueObjectRepresentationStyle val_obj_display,
530       lldb::Format custom_format);
531 
532   enum class PrintableRepresentationSpecialCases : bool {
533     eDisable = false,
534     eAllow = true
535   };
536 
537   bool
538   DumpPrintableRepresentation(Stream &s,
539                               ValueObjectRepresentationStyle val_obj_display =
540                                   eValueObjectRepresentationStyleSummary,
541                               lldb::Format custom_format = lldb::eFormatInvalid,
542                               PrintableRepresentationSpecialCases special =
543                                   PrintableRepresentationSpecialCases::eAllow,
544                               bool do_dump_error = true);
GetValueIsValid()545   bool GetValueIsValid() const { return m_flags.m_value_is_valid; }
546 
547   // If you call this on a newly created ValueObject, it will always return
548   // false.
GetValueDidChange()549   bool GetValueDidChange() { return m_flags.m_value_did_change; }
550 
551   bool UpdateValueIfNeeded(bool update_format = true);
552 
553   bool UpdateFormatsIfNeeded();
554 
GetSP()555   lldb::ValueObjectSP GetSP() { return m_manager->GetSharedPointer(this); }
556 
557   /// Change the name of the current ValueObject. Should *not* be used from a
558   /// synthetic child provider as it would change the name of the non synthetic
559   /// child as well.
SetName(ConstString name)560   void SetName(ConstString name) { m_name = name; }
561 
562   virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address = true,
563                                     AddressType *address_type = nullptr);
564 
565   lldb::addr_t GetPointerValue(AddressType *address_type = nullptr);
566 
567   lldb::ValueObjectSP GetSyntheticChild(ConstString key) const;
568 
569   lldb::ValueObjectSP GetSyntheticArrayMember(size_t index, bool can_create);
570 
571   lldb::ValueObjectSP GetSyntheticBitFieldChild(uint32_t from, uint32_t to,
572                                                 bool can_create);
573 
574   lldb::ValueObjectSP GetSyntheticExpressionPathChild(const char *expression,
575                                                       bool can_create);
576 
577   virtual lldb::ValueObjectSP
578   GetSyntheticChildAtOffset(uint32_t offset, const CompilerType &type,
579                             bool can_create,
580                             ConstString name_const_str = ConstString());
581 
582   virtual lldb::ValueObjectSP
583   GetSyntheticBase(uint32_t offset, const CompilerType &type, bool can_create,
584                    ConstString name_const_str = ConstString());
585 
586   virtual lldb::ValueObjectSP GetDynamicValue(lldb::DynamicValueType valueType);
587 
588   lldb::DynamicValueType GetDynamicValueType();
589 
GetStaticValue()590   virtual lldb::ValueObjectSP GetStaticValue() { return GetSP(); }
591 
GetNonSyntheticValue()592   virtual lldb::ValueObjectSP GetNonSyntheticValue() { return GetSP(); }
593 
594   lldb::ValueObjectSP GetSyntheticValue();
595 
596   virtual bool HasSyntheticValue();
597 
IsSynthetic()598   virtual bool IsSynthetic() { return false; }
599 
600   lldb::ValueObjectSP
601   GetQualifiedRepresentationIfAvailable(lldb::DynamicValueType dynValue,
602                                         bool synthValue);
603 
604   virtual lldb::ValueObjectSP CreateConstantValue(ConstString name);
605 
606   virtual lldb::ValueObjectSP Dereference(Status &error);
607 
608   /// Creates a copy of the ValueObject with a new name and setting the current
609   /// ValueObject as its parent. It should be used when we want to change the
610   /// name of a ValueObject without modifying the actual ValueObject itself
611   /// (e.g. sythetic child provider).
612   virtual lldb::ValueObjectSP Clone(ConstString new_name);
613 
614   virtual lldb::ValueObjectSP AddressOf(Status &error);
615 
GetLiveAddress()616   virtual lldb::addr_t GetLiveAddress() { return LLDB_INVALID_ADDRESS; }
617 
618   virtual void SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS,
619                               AddressType address_type = eAddressTypeLoad) {}
620 
621   virtual lldb::ValueObjectSP Cast(const CompilerType &compiler_type);
622 
623   virtual lldb::ValueObjectSP CastPointerType(const char *name,
624                                               CompilerType &ast_type);
625 
626   virtual lldb::ValueObjectSP CastPointerType(const char *name,
627                                               lldb::TypeSP &type_sp);
628 
629   // The backing bits of this value object were updated, clear any descriptive
630   // string, so we know we have to refetch them.
ValueUpdated()631   virtual void ValueUpdated() {
632     ClearUserVisibleData(eClearUserVisibleDataItemsValue |
633                          eClearUserVisibleDataItemsSummary |
634                          eClearUserVisibleDataItemsDescription);
635   }
636 
IsDynamic()637   virtual bool IsDynamic() { return false; }
638 
DoesProvideSyntheticValue()639   virtual bool DoesProvideSyntheticValue() { return false; }
640 
IsSyntheticChildrenGenerated()641   virtual bool IsSyntheticChildrenGenerated() {
642     return m_flags.m_is_synthetic_children_generated;
643   }
644 
SetSyntheticChildrenGenerated(bool b)645   virtual void SetSyntheticChildrenGenerated(bool b) {
646     m_flags.m_is_synthetic_children_generated = b;
647   }
648 
649   virtual SymbolContextScope *GetSymbolContextScope();
650 
651   void Dump(Stream &s);
652 
653   void Dump(Stream &s, const DumpValueObjectOptions &options);
654 
655   static lldb::ValueObjectSP
656   CreateValueObjectFromExpression(llvm::StringRef name,
657                                   llvm::StringRef expression,
658                                   const ExecutionContext &exe_ctx);
659 
660   static lldb::ValueObjectSP
661   CreateValueObjectFromExpression(llvm::StringRef name,
662                                   llvm::StringRef expression,
663                                   const ExecutionContext &exe_ctx,
664                                   const EvaluateExpressionOptions &options);
665 
666   static lldb::ValueObjectSP
667   CreateValueObjectFromAddress(llvm::StringRef name, uint64_t address,
668                                const ExecutionContext &exe_ctx,
669                                CompilerType type);
670 
671   static lldb::ValueObjectSP
672   CreateValueObjectFromData(llvm::StringRef name, const DataExtractor &data,
673                             const ExecutionContext &exe_ctx, CompilerType type);
674 
675   lldb::ValueObjectSP Persist();
676 
677   /// Returns true if this is a char* or a char[] if it is a char* and
678   /// check_pointer is true, it also checks that the pointer is valid.
679   bool IsCStringContainer(bool check_pointer = false);
680 
681   std::pair<size_t, bool>
682   ReadPointedString(lldb::WritableDataBufferSP &buffer_sp, Status &error,
683                     uint32_t max_length = 0, bool honor_array = true,
684                     lldb::Format item_format = lldb::eFormatCharArray);
685 
686   virtual size_t GetPointeeData(DataExtractor &data, uint32_t item_idx = 0,
687                                 uint32_t item_count = 1);
688 
689   virtual uint64_t GetData(DataExtractor &data, Status &error);
690 
691   virtual bool SetData(DataExtractor &data, Status &error);
692 
GetIsConstant()693   virtual bool GetIsConstant() const { return m_update_point.IsConstant(); }
694 
NeedsUpdating()695   bool NeedsUpdating() {
696     const bool accept_invalid_exe_ctx =
697         (CanUpdateWithInvalidExecutionContext() == eLazyBoolYes);
698     return m_update_point.NeedsUpdating(accept_invalid_exe_ctx);
699   }
700 
SetIsConstant()701   void SetIsConstant() { m_update_point.SetIsConstant(); }
702 
703   lldb::Format GetFormat() const;
704 
SetFormat(lldb::Format format)705   virtual void SetFormat(lldb::Format format) {
706     if (format != m_format)
707       ClearUserVisibleData(eClearUserVisibleDataItemsValue);
708     m_format = format;
709   }
710 
711   virtual lldb::LanguageType GetPreferredDisplayLanguage();
712 
SetPreferredDisplayLanguage(lldb::LanguageType lt)713   void SetPreferredDisplayLanguage(lldb::LanguageType lt) {
714     m_preferred_display_language = lt;
715   }
716 
GetSummaryFormat()717   lldb::TypeSummaryImplSP GetSummaryFormat() {
718     UpdateFormatsIfNeeded();
719     return m_type_summary_sp;
720   }
721 
SetSummaryFormat(lldb::TypeSummaryImplSP format)722   void SetSummaryFormat(lldb::TypeSummaryImplSP format) {
723     m_type_summary_sp = std::move(format);
724     ClearUserVisibleData(eClearUserVisibleDataItemsSummary);
725   }
726 
SetValueFormat(lldb::TypeFormatImplSP format)727   void SetValueFormat(lldb::TypeFormatImplSP format) {
728     m_type_format_sp = std::move(format);
729     ClearUserVisibleData(eClearUserVisibleDataItemsValue);
730   }
731 
GetValueFormat()732   lldb::TypeFormatImplSP GetValueFormat() {
733     UpdateFormatsIfNeeded();
734     return m_type_format_sp;
735   }
736 
SetSyntheticChildren(const lldb::SyntheticChildrenSP & synth_sp)737   void SetSyntheticChildren(const lldb::SyntheticChildrenSP &synth_sp) {
738     if (synth_sp.get() == m_synthetic_children_sp.get())
739       return;
740     ClearUserVisibleData(eClearUserVisibleDataItemsSyntheticChildren);
741     m_synthetic_children_sp = synth_sp;
742   }
743 
GetSyntheticChildren()744   lldb::SyntheticChildrenSP GetSyntheticChildren() {
745     UpdateFormatsIfNeeded();
746     return m_synthetic_children_sp;
747   }
748 
749   // Use GetParent for display purposes, but if you want to tell the parent to
750   // update itself then use m_parent.  The ValueObjectDynamicValue's parent is
751   // not the correct parent for displaying, they are really siblings, so for
752   // display it needs to route through to its grandparent.
GetParent()753   virtual ValueObject *GetParent() { return m_parent; }
754 
GetParent()755   virtual const ValueObject *GetParent() const { return m_parent; }
756 
757   ValueObject *GetNonBaseClassParent();
758 
SetAddressTypeOfChildren(AddressType at)759   void SetAddressTypeOfChildren(AddressType at) {
760     m_address_type_of_ptr_or_ref_children = at;
761   }
762 
763   AddressType GetAddressTypeOfChildren();
764 
SetHasCompleteType()765   void SetHasCompleteType() {
766     m_flags.m_did_calculate_complete_objc_class_type = true;
767   }
768 
769   /// Find out if a ValueObject might have children.
770   ///
771   /// This call is much more efficient than CalculateNumChildren() as
772   /// it doesn't need to complete the underlying type. This is designed
773   /// to be used in a UI environment in order to detect if the
774   /// disclosure triangle should be displayed or not.
775   ///
776   /// This function returns true for class, union, structure,
777   /// pointers, references, arrays and more. Again, it does so without
778   /// doing any expensive type completion.
779   ///
780   /// \return
781   ///     Returns \b true if the ValueObject might have children, or \b
782   ///     false otherwise.
783   virtual bool MightHaveChildren();
784 
GetVariable()785   virtual lldb::VariableSP GetVariable() { return nullptr; }
786 
787   virtual bool IsRuntimeSupportValue();
788 
GetLanguageFlags()789   virtual uint64_t GetLanguageFlags() { return m_language_flags; }
790 
SetLanguageFlags(uint64_t flags)791   virtual void SetLanguageFlags(uint64_t flags) { m_language_flags = flags; }
792 
793 protected:
794   typedef ClusterManager<ValueObject> ValueObjectManager;
795 
796   class ChildrenManager {
797   public:
798     ChildrenManager() = default;
799 
HasChildAtIndex(size_t idx)800     bool HasChildAtIndex(size_t idx) {
801       std::lock_guard<std::recursive_mutex> guard(m_mutex);
802       return (m_children.find(idx) != m_children.end());
803     }
804 
GetChildAtIndex(size_t idx)805     ValueObject *GetChildAtIndex(size_t idx) {
806       std::lock_guard<std::recursive_mutex> guard(m_mutex);
807       const auto iter = m_children.find(idx);
808       return ((iter == m_children.end()) ? nullptr : iter->second);
809     }
810 
SetChildAtIndex(size_t idx,ValueObject * valobj)811     void SetChildAtIndex(size_t idx, ValueObject *valobj) {
812       // we do not need to be mutex-protected to make a pair
813       ChildrenPair pair(idx, valobj);
814       std::lock_guard<std::recursive_mutex> guard(m_mutex);
815       m_children.insert(pair);
816     }
817 
SetChildrenCount(size_t count)818     void SetChildrenCount(size_t count) { Clear(count); }
819 
GetChildrenCount()820     size_t GetChildrenCount() { return m_children_count; }
821 
822     void Clear(size_t new_count = 0) {
823       std::lock_guard<std::recursive_mutex> guard(m_mutex);
824       m_children_count = new_count;
825       m_children.clear();
826     }
827 
828   private:
829     typedef std::map<size_t, ValueObject *> ChildrenMap;
830     typedef ChildrenMap::iterator ChildrenIterator;
831     typedef ChildrenMap::value_type ChildrenPair;
832     std::recursive_mutex m_mutex;
833     ChildrenMap m_children;
834     size_t m_children_count = 0;
835   };
836 
837   // Classes that inherit from ValueObject can see and modify these
838 
839   /// The parent value object, or nullptr if this has no parent.
840   ValueObject *m_parent = nullptr;
841   /// The root of the hierarchy for this ValueObject (or nullptr if never
842   /// calculated).
843   ValueObject *m_root = nullptr;
844   /// Stores both the stop id and the full context at which this value was last
845   /// updated.  When we are asked to update the value object, we check whether
846   /// the context & stop id are the same before updating.
847   EvaluationPoint m_update_point;
848   /// The name of this object.
849   ConstString m_name;
850   /// A data extractor that can be used to extract the value.
851   DataExtractor m_data;
852   Value m_value;
853   /// An error object that can describe any errors that occur when updating
854   /// values.
855   Status m_error;
856   /// Cached value string that will get cleared if/when the value is updated.
857   std::string m_value_str;
858   /// Cached old value string from the last time the value was gotten
859   std::string m_old_value_str;
860   /// Cached location string that will get cleared if/when the value is updated.
861   std::string m_location_str;
862   /// Cached summary string that will get cleared if/when the value is updated.
863   std::string m_summary_str;
864   /// Cached result of the "object printer". This differs from the summary
865   /// in that the summary is consed up by us, the object_desc_string is builtin.
866   std::string m_object_desc_str;
867   /// If the type of the value object should be overridden, the type to impose.
868   CompilerType m_override_type;
869 
870   /// This object is managed by the root object (any ValueObject that gets
871   /// created without a parent.) The manager gets passed through all the
872   /// generations of dependent objects, and will keep the whole cluster of
873   /// objects alive as long as a shared pointer to any of them has been handed
874   /// out. Shared pointers to value objects must always be made with the GetSP
875   /// method.
876   ValueObjectManager *m_manager = nullptr;
877 
878   ChildrenManager m_children;
879   std::map<ConstString, ValueObject *> m_synthetic_children;
880 
881   ValueObject *m_dynamic_value = nullptr;
882   ValueObject *m_synthetic_value = nullptr;
883   ValueObject *m_deref_valobj = nullptr;
884 
885   /// We have to hold onto a shared  pointer to this one because it is created
886   /// as an independent ValueObjectConstResult, which isn't managed by us.
887   lldb::ValueObjectSP m_addr_of_valobj_sp;
888 
889   lldb::Format m_format = lldb::eFormatDefault;
890   lldb::Format m_last_format = lldb::eFormatDefault;
891   uint32_t m_last_format_mgr_revision = 0;
892   lldb::TypeSummaryImplSP m_type_summary_sp;
893   lldb::TypeFormatImplSP m_type_format_sp;
894   lldb::SyntheticChildrenSP m_synthetic_children_sp;
895   ProcessModID m_user_id_of_forced_summary;
896   AddressType m_address_type_of_ptr_or_ref_children = eAddressTypeInvalid;
897 
898   llvm::SmallVector<uint8_t, 16> m_value_checksum;
899 
900   lldb::LanguageType m_preferred_display_language = lldb::eLanguageTypeUnknown;
901 
902   uint64_t m_language_flags = 0;
903 
904   /// Unique identifier for every value object.
905   UserID m_id;
906 
907   // Utility class for initializing all bitfields in ValueObject's constructors.
908   // FIXME: This could be done via default initializers once we have C++20.
909   struct Bitflags {
910     bool m_value_is_valid : 1, m_value_did_change : 1,
911         m_children_count_valid : 1, m_old_value_valid : 1,
912         m_is_deref_of_parent : 1, m_is_array_item_for_pointer : 1,
913         m_is_bitfield_for_scalar : 1, m_is_child_at_offset : 1,
914         m_is_getting_summary : 1, m_did_calculate_complete_objc_class_type : 1,
915         m_is_synthetic_children_generated : 1;
BitflagsBitflags916     Bitflags() {
917       m_value_is_valid = false;
918       m_value_did_change = false;
919       m_children_count_valid = false;
920       m_old_value_valid = false;
921       m_is_deref_of_parent = false;
922       m_is_array_item_for_pointer = false;
923       m_is_bitfield_for_scalar = false;
924       m_is_child_at_offset = false;
925       m_is_getting_summary = false;
926       m_did_calculate_complete_objc_class_type = false;
927       m_is_synthetic_children_generated = false;
928     }
929   } m_flags;
930 
931   friend class ValueObjectChild;
932   friend class ExpressionVariable;     // For SetName
933   friend class Target;                 // For SetName
934   friend class ValueObjectConstResultImpl;
935   friend class ValueObjectSynthetic; // For ClearUserVisibleData
936 
937   /// Use this constructor to create a "root variable object".  The ValueObject
938   /// will be locked to this context through-out its lifespan.
939   ValueObject(ExecutionContextScope *exe_scope, ValueObjectManager &manager,
940               AddressType child_ptr_or_ref_addr_type = eAddressTypeLoad);
941 
942   /// Use this constructor to create a ValueObject owned by another ValueObject.
943   /// It will inherit the ExecutionContext of its parent.
944   ValueObject(ValueObject &parent);
945 
GetManager()946   ValueObjectManager *GetManager() { return m_manager; }
947 
948   virtual bool UpdateValue() = 0;
949 
CanUpdateWithInvalidExecutionContext()950   virtual LazyBool CanUpdateWithInvalidExecutionContext() {
951     return eLazyBoolCalculate;
952   }
953 
954   virtual void CalculateDynamicValue(lldb::DynamicValueType use_dynamic);
955 
GetDynamicValueTypeImpl()956   virtual lldb::DynamicValueType GetDynamicValueTypeImpl() {
957     return lldb::eNoDynamicValues;
958   }
959 
HasDynamicValueTypeInfo()960   virtual bool HasDynamicValueTypeInfo() { return false; }
961 
962   virtual void CalculateSyntheticValue();
963 
964   /// Should only be called by ValueObject::GetChildAtIndex().
965   ///
966   /// \return A ValueObject managed by this ValueObject's manager.
967   virtual ValueObject *CreateChildAtIndex(size_t idx,
968                                           bool synthetic_array_member,
969                                           int32_t synthetic_index);
970 
971   /// Should only be called by ValueObject::GetNumChildren().
972   virtual size_t CalculateNumChildren(uint32_t max = UINT32_MAX) = 0;
973 
974   void SetNumChildren(size_t num_children);
975 
SetValueDidChange(bool value_changed)976   void SetValueDidChange(bool value_changed) {
977     m_flags.m_value_did_change = value_changed;
978   }
979 
SetValueIsValid(bool valid)980   void SetValueIsValid(bool valid) { m_flags.m_value_is_valid = valid; }
981 
982   void ClearUserVisibleData(
983       uint32_t items = ValueObject::eClearUserVisibleDataItemsAllStrings);
984 
985   void AddSyntheticChild(ConstString key, ValueObject *valobj);
986 
987   DataExtractor &GetDataExtractor();
988 
989   void ClearDynamicTypeInformation();
990 
991   // Subclasses must implement the functions below.
992 
993   virtual CompilerType GetCompilerTypeImpl() = 0;
994 
995   const char *GetLocationAsCStringImpl(const Value &value,
996                                        const DataExtractor &data);
997 
IsChecksumEmpty()998   bool IsChecksumEmpty() { return m_value_checksum.empty(); }
999 
1000   void SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType);
1001 
1002 protected:
DoUpdateChildrenAddressType(ValueObject & valobj)1003   virtual void DoUpdateChildrenAddressType(ValueObject &valobj){};
1004 
1005 private:
1006   virtual CompilerType MaybeCalculateCompleteType();
UpdateChildrenAddressType()1007   void UpdateChildrenAddressType() {
1008     GetRoot()->DoUpdateChildrenAddressType(*this);
1009   }
1010 
1011   lldb::ValueObjectSP GetValueForExpressionPath_Impl(
1012       llvm::StringRef expression_cstr,
1013       ExpressionPathScanEndReason *reason_to_stop,
1014       ExpressionPathEndResultType *final_value_type,
1015       const GetValueForExpressionPathOptions &options,
1016       ExpressionPathAftermath *final_task_on_target);
1017 
1018   ValueObject(const ValueObject &) = delete;
1019   const ValueObject &operator=(const ValueObject &) = delete;
1020 };
1021 
1022 } // namespace lldb_private
1023 
1024 #endif // LLDB_CORE_VALUEOBJECT_H
1025