1//===-- ValueObjectSyntheticFilter.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 liblldb_ValueObjectSyntheticFilter_h_
10#define liblldb_ValueObjectSyntheticFilter_h_
11
12#include "lldb/Core/ValueObject.h"
13#include "lldb/Symbol/CompilerType.h"
14#include "lldb/Utility/ConstString.h"
15#include "lldb/lldb-defines.h"
16#include "lldb/lldb-enumerations.h"
17#include "lldb/lldb-forward.h"
18#include "lldb/lldb-private-enumerations.h"
19
20#include <cstdint>
21#include <memory>
22
23#include <stddef.h>
24
25namespace lldb_private {
26class Declaration;
27class Status;
28class SyntheticChildrenFrontEnd;
29
30// A ValueObject that obtains its children from some source other than
31// real information
32// This is currently used to implement Python-based children and filters but
33// you can bind it to any source of synthetic information and have it behave
34// accordingly
35class ValueObjectSynthetic : public ValueObject {
36public:
37  ~ValueObjectSynthetic() override;
38
39  uint64_t GetByteSize() override;
40
41  ConstString GetTypeName() override;
42
43  ConstString GetQualifiedTypeName() override;
44
45  ConstString GetDisplayTypeName() override;
46
47  bool MightHaveChildren() override;
48
49  size_t CalculateNumChildren(uint32_t max) override;
50
51  lldb::ValueType GetValueType() const override;
52
53  lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create) override;
54
55  lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
56                                             bool can_create) override;
57
58  size_t GetIndexOfChildWithName(ConstString name) override;
59
60  lldb::ValueObjectSP
61  GetDynamicValue(lldb::DynamicValueType valueType) override;
62
63  bool IsInScope() override;
64
65  bool HasSyntheticValue() override { return false; }
66
67  bool IsSynthetic() override { return true; }
68
69  void CalculateSyntheticValue(bool use_synthetic) override {}
70
71  bool IsDynamic() override {
72    return ((m_parent != nullptr) ? m_parent->IsDynamic() : false);
73  }
74
75  lldb::ValueObjectSP GetStaticValue() override {
76    return ((m_parent != nullptr) ? m_parent->GetStaticValue() : GetSP());
77  }
78
79  virtual lldb::DynamicValueType GetDynamicValueType() {
80    return ((m_parent != nullptr) ? m_parent->GetDynamicValueType()
81                                  : lldb::eNoDynamicValues);
82  }
83
84  ValueObject *GetParent() override {
85    return ((m_parent != nullptr) ? m_parent->GetParent() : nullptr);
86  }
87
88  const ValueObject *GetParent() const override {
89    return ((m_parent != nullptr) ? m_parent->GetParent() : nullptr);
90  }
91
92  lldb::ValueObjectSP GetNonSyntheticValue() override;
93
94  bool CanProvideValue() override;
95
96  bool DoesProvideSyntheticValue() override {
97    return (UpdateValueIfNeeded(), m_provides_value == eLazyBoolYes);
98  }
99
100  bool GetIsConstant() const override { return false; }
101
102  bool SetValueFromCString(const char *value_str, Status &error) override;
103
104  void SetFormat(lldb::Format format) override;
105
106  lldb::LanguageType GetPreferredDisplayLanguage() override;
107
108  void SetPreferredDisplayLanguage(lldb::LanguageType);
109
110  bool IsSyntheticChildrenGenerated() override;
111
112  void SetSyntheticChildrenGenerated(bool b) override;
113
114  bool GetDeclaration(Declaration &decl) override;
115
116  uint64_t GetLanguageFlags() override;
117
118  void SetLanguageFlags(uint64_t flags) override;
119
120protected:
121  bool UpdateValue() override;
122
123  LazyBool CanUpdateWithInvalidExecutionContext() override {
124    return eLazyBoolYes;
125  }
126
127  CompilerType GetCompilerTypeImpl() override;
128
129  virtual void CreateSynthFilter();
130
131  // we need to hold on to the SyntheticChildren because someone might delete
132  // the type binding while we are alive
133  lldb::SyntheticChildrenSP m_synth_sp;
134  std::unique_ptr<SyntheticChildrenFrontEnd> m_synth_filter_up;
135
136  typedef std::map<uint32_t, ValueObject *> ByIndexMap;
137  typedef std::map<const char *, uint32_t> NameToIndexMap;
138  typedef std::vector<lldb::ValueObjectSP> SyntheticChildrenCache;
139
140  typedef ByIndexMap::iterator ByIndexIterator;
141  typedef NameToIndexMap::iterator NameToIndexIterator;
142
143  std::mutex m_child_mutex;
144  /// Guarded by m_child_mutex;
145  ByIndexMap m_children_byindex;
146  /// Guarded by m_child_mutex;
147  NameToIndexMap m_name_toindex;
148  /// Guarded by m_child_mutex;
149  SyntheticChildrenCache m_synthetic_children_cache;
150
151  uint32_t m_synthetic_children_count; // FIXME use the ValueObject's
152                                       // ChildrenManager instead of a special
153                                       // purpose solution
154
155  ConstString m_parent_type_name;
156
157  LazyBool m_might_have_children;
158
159  LazyBool m_provides_value;
160
161private:
162  friend class ValueObject;
163  ValueObjectSynthetic(ValueObject &parent, lldb::SyntheticChildrenSP filter);
164
165  void CopyValueData(ValueObject *source);
166
167  DISALLOW_COPY_AND_ASSIGN(ValueObjectSynthetic);
168};
169
170} // namespace lldb_private
171
172#endif // liblldb_ValueObjectSyntheticFilter_h_
173