Coverage Report

Created: 2022-01-18 06:27

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Core/ValueObject.h
Line
Count
Source (jump to first uncovered line)
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/Optional.h"
30
#include "llvm/ADT/SmallVector.h"
31
#include "llvm/ADT/StringRef.h"
32
33
#include <functional>
34
#include <initializer_list>
35
#include <map>
36
#include <mutex>
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
4.95k
          m_synthetic_children_traversal(synth_traverse) {}
216
217
0
    GetValueForExpressionPathOptions &DoCheckDotVsArrowSyntax() {
218
0
      m_check_dot_vs_arrow_syntax = true;
219
0
      return *this;
220
0
    }
221
222
4.60k
    GetValueForExpressionPathOptions &DontCheckDotVsArrowSyntax() {
223
4.60k
      m_check_dot_vs_arrow_syntax = false;
224
4.60k
      return *this;
225
4.60k
    }
226
227
4.55k
    GetValueForExpressionPathOptions &DoAllowFragileIVar() {
228
4.55k
      m_no_fragile_ivar = false;
229
4.55k
      return *this;
230
4.55k
    }
231
232
0
    GetValueForExpressionPathOptions &DontAllowFragileIVar() {
233
0
      m_no_fragile_ivar = true;
234
0
      return *this;
235
0
    }
236
237
4.55k
    GetValueForExpressionPathOptions &DoAllowBitfieldSyntax() {
238
4.55k
      m_allow_bitfields_syntax = true;
239
4.55k
      return *this;
240
4.55k
    }
241
242
0
    GetValueForExpressionPathOptions &DontAllowBitfieldSyntax() {
243
0
      m_allow_bitfields_syntax = false;
244
0
      return *this;
245
0
    }
246
247
    GetValueForExpressionPathOptions &
248
4.69k
    SetSyntheticChildrenTraversal(SyntheticChildrenTraversal traverse) {
249
4.69k
      m_synthetic_children_traversal = traverse;
250
4.69k
      return *this;
251
4.69k
    }
252
253
46
    static const GetValueForExpressionPathOptions DefaultOptions() {
254
46
      static GetValueForExpressionPathOptions g_default_options;
255
256
46
      return g_default_options;
257
46
    }
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
1.71M
    const ExecutionContextRef &GetExecutionContextRef() const {
272
1.71M
      return m_exe_ctx_ref;
273
1.71M
    }
274
275
40.7k
    void SetIsConstant() {
276
40.7k
      SetUpdated();
277
40.7k
      m_mod_id.SetInvalid();
278
40.7k
    }
279
280
1.07M
    bool IsConstant() const { return !m_mod_id.IsValid(); }
281
282
0
    ProcessModID GetModID() const { return m_mod_id; }
283
284
0
    void SetUpdateID(ProcessModID new_id) { m_mod_id = new_id; }
285
286
47
    void SetNeedsUpdate() { m_needs_update = true; }
287
288
    void SetUpdated();
289
290
737k
    bool NeedsUpdating(bool accept_invalid_exe_ctx) {
291
737k
      SyncWithProcessState(accept_invalid_exe_ctx);
292
737k
      return m_needs_update;
293
737k
    }
294
295
0
    bool IsValid() {
296
0
      const bool accept_invalid_exe_ctx = false;
297
0
      if (!m_mod_id.IsValid())
298
0
        return false;
299
0
      else if (SyncWithProcessState(accept_invalid_exe_ctx)) {
300
0
        if (!m_mod_id.IsValid())
301
0
          return false;
302
0
      }
303
0
      return true;
304
0
    }
305
306
411
    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
411
      m_mod_id.SetInvalid();
310
311
      // Can't update an invalid state.
312
411
      m_needs_update = false;
313
411
    }
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
0
  const EvaluationPoint &GetUpdatePoint() const { return m_update_point; }
327
328
169k
  EvaluationPoint &GetUpdatePoint() { return m_update_point; }
329
330
726k
  const ExecutionContextRef &GetExecutionContextRef() const {
331
726k
    return m_update_point.GetExecutionContextRef();
332
726k
  }
333
334
705k
  lldb::TargetSP GetTargetSP() const {
335
705k
    return m_update_point.GetExecutionContextRef().GetTargetSP();
336
705k
  }
337
338
161k
  lldb::ProcessSP GetProcessSP() const {
339
161k
    return m_update_point.GetExecutionContextRef().GetProcessSP();
340
161k
  }
341
342
0
  lldb::ThreadSP GetThreadSP() const {
343
0
    return m_update_point.GetExecutionContextRef().GetThreadSP();
344
0
  }
345
346
11.5k
  lldb::StackFrameSP GetFrameSP() const {
347
11.5k
    return m_update_point.GetExecutionContextRef().GetFrameSP();
348
11.5k
  }
349
350
  void SetNeedsUpdate();
351
352
3.11M
  CompilerType GetCompilerType() { return MaybeCalculateCompleteType(); }
353
354
  // this vends a TypeImpl that is useful at the SB API layer
355
588
  virtual TypeImpl GetTypeImpl() { return TypeImpl(GetCompilerType()); }
356
357
  virtual bool CanProvideValue();
358
359
  // Subclasses must implement the functions below.
360
  virtual llvm::Optional<uint64_t> GetByteSize() = 0;
361
362
  virtual lldb::ValueType GetValueType() const = 0;
363
364
  // Subclasses can implement the functions below.
365
33
  virtual ConstString GetTypeName() { return GetCompilerType().GetTypeName(); }
366
367
20
  virtual ConstString GetDisplayTypeName() { return GetTypeName(); }
368
369
76.4k
  virtual ConstString GetQualifiedTypeName() {
370
76.4k
    return GetCompilerType().GetTypeName();
371
76.4k
  }
372
373
798k
  virtual lldb::LanguageType GetObjectRuntimeLanguage() {
374
798k
    return GetCompilerType().GetMinimumLanguage();
375
798k
  }
376
377
  virtual uint32_t
378
39.5k
  GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) {
379
39.5k
    return GetCompilerType().GetTypeInfo(pointee_or_element_compiler_type);
380
39.5k
  }
381
382
17.7k
  virtual bool IsPointerType() { return GetCompilerType().IsPointerType(); }
383
384
54
  virtual bool IsArrayType() { return GetCompilerType().IsArrayType(); }
385
386
69
  virtual bool IsScalarType() { return GetCompilerType().IsScalarType(); }
387
388
2.03k
  virtual bool IsPointerOrReferenceType() {
389
2.03k
    return GetCompilerType().IsPointerOrReferenceType();
390
2.03k
  }
391
392
  virtual bool IsPossibleDynamicType();
393
394
  bool IsNilReference();
395
396
  bool IsUninitializedReference();
397
398
6.98k
  virtual bool IsBaseClass() { return false; }
399
400
  bool IsBaseClass(uint32_t &depth);
401
402
1.49k
  virtual bool IsDereferenceOfParent() { return false; }
403
404
0
  bool IsIntegerType(bool &is_signed) {
405
0
    return GetCompilerType().IsIntegerType(is_signed);
406
0
  }
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
2.31k
  virtual bool IsInScope() { return true; }
421
422
0
  virtual lldb::offset_t GetByteOffset() { return 0; }
423
424
94.8k
  virtual uint32_t GetBitfieldBitSize() { return 0; }
425
426
38.4k
  virtual uint32_t GetBitfieldBitOffset() { return 0; }
427
428
13.1k
  bool IsBitfield() {
429
13.1k
    return (GetBitfieldBitSize() != 0) || 
(GetBitfieldBitOffset() != 0)13.0k
;
430
13.1k
  }
431
432
0
  virtual bool IsArrayItemForPointer() {
433
0
    return m_flags.m_is_array_item_for_pointer;
434
0
  }
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
467
461k
  ConstString GetName() const { return m_name; }
468
469
  /// Returns a unique id for this ValueObject.
470
120
  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
497
0
  const Value &GetValue() const { return m_value; }
498
499
414k
  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
508
477
  virtual const char *GetLocationAsCString() {
509
477
    return GetLocationAsCStringImpl(m_value, m_data);
510
477
  }
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);
545
82.3k
  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.
549
204
  bool GetValueDidChange() { return m_flags.m_value_did_change; }
550
551
  bool UpdateValueIfNeeded(bool update_format = true);
552
553
  bool UpdateFormatsIfNeeded();
554
555
653k
  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.
560
42.9k
  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
590
0
  virtual lldb::ValueObjectSP GetStaticValue() { return GetSP(); }
591
592
129
  virtual lldb::ValueObjectSP GetNonSyntheticValue() { return GetSP(); }
593
594
  lldb::ValueObjectSP GetSyntheticValue();
595
596
  virtual bool HasSyntheticValue();
597
598
689k
  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
616
0
  virtual lldb::addr_t GetLiveAddress() { return LLDB_INVALID_ADDRESS; }
617
618
  virtual void SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS,
619
0
                              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.
631
8.82k
  virtual void ValueUpdated() {
632
8.82k
    ClearUserVisibleData(eClearUserVisibleDataItemsValue |
633
8.82k
                         eClearUserVisibleDataItemsSummary |
634
8.82k
                         eClearUserVisibleDataItemsDescription);
635
8.82k
  }
636
637
584k
  virtual bool IsDynamic() { return false; }
638
639
52
  virtual bool DoesProvideSyntheticValue() { return false; }
640
641
16.4k
  virtual bool IsSyntheticChildrenGenerated() {
642
16.4k
    return m_flags.m_is_synthetic_children_generated;
643
16.4k
  }
644
645
14.5k
  virtual void SetSyntheticChildrenGenerated(bool b) {
646
14.5k
    m_flags.m_is_synthetic_children_generated = b;
647
14.5k
  }
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::DataBufferSP &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
693
1.07M
  virtual bool GetIsConstant() const { return m_update_point.IsConstant(); }
694
695
737k
  bool NeedsUpdating() {
696
737k
    const bool accept_invalid_exe_ctx =
697
737k
        (CanUpdateWithInvalidExecutionContext() == eLazyBoolYes);
698
737k
    return m_update_point.NeedsUpdating(accept_invalid_exe_ctx);
699
737k
  }
700
701
40.7k
  void SetIsConstant() { m_update_point.SetIsConstant(); }
702
703
  lldb::Format GetFormat() const;
704
705
1.94k
  virtual void SetFormat(lldb::Format format) {
706
1.94k
    if (format != m_format)
707
1.65k
      ClearUserVisibleData(eClearUserVisibleDataItemsValue);
708
1.94k
    m_format = format;
709
1.94k
  }
710
711
  virtual lldb::LanguageType GetPreferredDisplayLanguage();
712
713
23.7k
  void SetPreferredDisplayLanguage(lldb::LanguageType lt) {
714
23.7k
    m_preferred_display_language = lt;
715
23.7k
  }
716
717
205k
  lldb::TypeSummaryImplSP GetSummaryFormat() {
718
205k
    UpdateFormatsIfNeeded();
719
205k
    return m_type_summary_sp;
720
205k
  }
721
722
93.6k
  void SetSummaryFormat(lldb::TypeSummaryImplSP format) {
723
93.6k
    m_type_summary_sp = std::move(format);
724
93.6k
    ClearUserVisibleData(eClearUserVisibleDataItemsSummary);
725
93.6k
  }
726
727
93.6k
  void SetValueFormat(lldb::TypeFormatImplSP format) {
728
93.6k
    m_type_format_sp = std::move(format);
729
93.6k
    ClearUserVisibleData(eClearUserVisibleDataItemsValue);
730
93.6k
  }
731
732
0
  lldb::TypeFormatImplSP GetValueFormat() {
733
0
    UpdateFormatsIfNeeded();
734
0
    return m_type_format_sp;
735
0
  }
736
737
93.6k
  void SetSyntheticChildren(const lldb::SyntheticChildrenSP &synth_sp) {
738
93.6k
    if (synth_sp.get() == m_synthetic_children_sp.get())
739
88.5k
      return;
740
5.09k
    ClearUserVisibleData(eClearUserVisibleDataItemsSyntheticChildren);
741
5.09k
    m_synthetic_children_sp = synth_sp;
742
5.09k
  }
743
744
19.8k
  lldb::SyntheticChildrenSP GetSyntheticChildren() {
745
19.8k
    UpdateFormatsIfNeeded();
746
19.8k
    return m_synthetic_children_sp;
747
19.8k
  }
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.
753
25.0k
  virtual ValueObject *GetParent() { return m_parent; }
754
755
0
  virtual const ValueObject *GetParent() const { return m_parent; }
756
757
  ValueObject *GetNonBaseClassParent();
758
759
174k
  void SetAddressTypeOfChildren(AddressType at) {
760
174k
    m_address_type_of_ptr_or_ref_children = at;
761
174k
  }
762
763
  AddressType GetAddressTypeOfChildren();
764
765
30
  void SetHasCompleteType() {
766
30
    m_flags.m_did_calculate_complete_objc_class_type = true;
767
30
  }
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
785
33
  virtual lldb::VariableSP GetVariable() { return nullptr; }
786
787
  virtual bool IsRuntimeSupportValue();
788
789
0
  virtual uint64_t GetLanguageFlags() { return m_language_flags; }
790
791
56.9k
  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
142k
    ChildrenManager() {}
799
800
127k
    bool HasChildAtIndex(size_t idx) {
801
127k
      std::lock_guard<std::recursive_mutex> guard(m_mutex);
802
127k
      return (m_children.find(idx) != m_children.end());
803
127k
    }
804
805
127k
    ValueObject *GetChildAtIndex(size_t idx) {
806
127k
      std::lock_guard<std::recursive_mutex> guard(m_mutex);
807
127k
      const auto iter = m_children.find(idx);
808
127k
      return ((iter == m_children.end()) ? 
nullptr0
: iter->second);
809
127k
    }
810
811
53.9k
    void SetChildAtIndex(size_t idx, ValueObject *valobj) {
812
      // we do not need to be mutex-protected to make a pair
813
53.9k
      ChildrenPair pair(idx, valobj);
814
53.9k
      std::lock_guard<std::recursive_mutex> guard(m_mutex);
815
53.9k
      m_children.insert(pair);
816
53.9k
    }
817
818
71.3k
    void SetChildrenCount(size_t count) { Clear(count); }
819
820
270k
    size_t GetChildrenCount() { return m_children_count; }
821
822
71.3k
    void Clear(size_t new_count = 0) {
823
71.3k
      std::lock_guard<std::recursive_mutex> guard(m_mutex);
824
71.3k
      m_children_count = new_count;
825
71.3k
      m_children.clear();
826
71.3k
    }
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;
916
142k
    Bitflags() {
917
142k
      m_value_is_valid = false;
918
142k
      m_value_did_change = false;
919
142k
      m_children_count_valid = false;
920
142k
      m_old_value_valid = false;
921
142k
      m_is_deref_of_parent = false;
922
142k
      m_is_array_item_for_pointer = false;
923
142k
      m_is_bitfield_for_scalar = false;
924
142k
      m_is_child_at_offset = false;
925
142k
      m_is_getting_summary = false;
926
142k
      m_did_calculate_complete_objc_class_type = false;
927
142k
      m_is_synthetic_children_generated = false;
928
142k
    }
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
946
62.5k
  ValueObjectManager *GetManager() { return m_manager; }
947
948
  virtual bool UpdateValue() = 0;
949
950
262k
  virtual LazyBool CanUpdateWithInvalidExecutionContext() {
951
262k
    return eLazyBoolCalculate;
952
262k
  }
953
954
  virtual void CalculateDynamicValue(lldb::DynamicValueType use_dynamic);
955
956
0
  virtual lldb::DynamicValueType GetDynamicValueTypeImpl() {
957
0
    return lldb::eNoDynamicValues;
958
0
  }
959
960
234M
  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
976
186k
  void SetValueDidChange(bool value_changed) {
977
186k
    m_flags.m_value_did_change = value_changed;
978
186k
  }
979
980
228k
  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
998
737k
  bool IsChecksumEmpty() { return m_value_checksum.empty(); }
999
1000
  void SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType);
1001
1002
protected:
1003
19.0k
  virtual void DoUpdateChildrenAddressType(ValueObject &valobj){};
1004
1005
private:
1006
  virtual CompilerType MaybeCalculateCompleteType();
1007
81.9k
  void UpdateChildrenAddressType() {
1008
81.9k
    GetRoot()->DoUpdateChildrenAddressType(*this);
1009
81.9k
  }
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