LLDB mainline
ExpressionVariable.h
Go to the documentation of this file.
1//===-- ExpressionVariable.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_EXPRESSION_EXPRESSIONVARIABLE_H
10#define LLDB_EXPRESSION_EXPRESSIONVARIABLE_H
11
12#include <memory>
13#include <optional>
14#include <vector>
15
16#include "llvm/ADT/DenseMap.h"
17
20#include "lldb/lldb-public.h"
21
22namespace lldb_private {
23
25 : public std::enable_shared_from_this<ExpressionVariable> {
26public:
27 // See TypeSystem.h for how to add subclasses to this.
29
30 LLVMCastKind getKind() const { return m_kind; }
31
34
35 std::optional<uint64_t> GetByteSize() { return m_frozen_sp->GetByteSize(); }
36
37 ConstString GetName() { return m_frozen_sp->GetName(); }
38
39 lldb::ValueObjectSP GetValueObject() { return m_frozen_sp; }
40
41 uint8_t *GetValueBytes();
42
43 void ValueUpdated() { m_frozen_sp->ValueUpdated(); }
44
45 RegisterInfo *GetRegisterInfo() {
46 return m_frozen_sp->GetValue().GetRegisterInfo();
47 }
48
49 void SetRegisterInfo(const RegisterInfo *reg_info) {
50 return m_frozen_sp->GetValue().SetContext(
51 Value::ContextType::RegisterInfo, const_cast<RegisterInfo *>(reg_info));
52 }
53
54 CompilerType GetCompilerType() { return m_frozen_sp->GetCompilerType(); }
55
56 void SetCompilerType(const CompilerType &compiler_type) {
57 m_frozen_sp->GetValue().SetCompilerType(compiler_type);
58 }
59
60 void SetName(ConstString name) { m_frozen_sp->SetName(name); }
61
62 // this function is used to copy the address-of m_live_sp into m_frozen_sp
63 // this is necessary because the results of certain cast and pointer-
64 // arithmetic operations (such as those described in bugzilla issues 11588
65 // and 11618) generate frozen objects that do not have a valid address-of,
66 // which can be troublesome when using synthetic children providers.
67 // Transferring the address-of the live object solves these issues and
68 // provides the expected user-level behavior
69 void TransferAddress(bool force = false) {
70 if (m_live_sp.get() == nullptr)
71 return;
72
73 if (m_frozen_sp.get() == nullptr)
74 return;
75
76 if (force || (m_frozen_sp->GetLiveAddress() == LLDB_INVALID_ADDRESS))
77 m_frozen_sp->SetLiveAddress(m_live_sp->GetLiveAddress());
78 }
79
80 enum Flags {
81 EVNone = 0,
82 EVIsLLDBAllocated = 1 << 0, ///< This variable is resident in a location
83 ///specifically allocated for it by LLDB in the
84 ///target process
85 EVIsProgramReference = 1 << 1, ///< This variable is a reference to a
86 ///(possibly invalid) area managed by the
87 ///target program
88 EVNeedsAllocation = 1 << 2, ///< Space for this variable has yet to be
89 ///allocated in the target process
90 EVIsFreezeDried = 1 << 3, ///< This variable's authoritative version is in
91 ///m_frozen_sp (for example, for
92 ///statically-computed results)
94 1 << 4, ///< Copy from m_live_sp to m_frozen_sp during dematerialization
95 EVKeepInTarget = 1 << 5, ///< Keep the allocation after the expression is
96 ///complete rather than freeze drying its contents
97 ///and freeing it
98 EVTypeIsReference = 1 << 6, ///< The original type of this variable is a
99 ///reference, so materialize the value rather
100 ///than the location
101 EVBareRegister = 1 << 7 ///< This variable is a direct reference to $pc or
102 ///some other entity.
103 };
104
106
107 FlagType m_flags; // takes elements of Flags
108
109 // these should be private
110 lldb::ValueObjectSP m_frozen_sp;
111 lldb::ValueObjectSP m_live_sp;
113};
114
115/// \class ExpressionVariableList ExpressionVariable.h
116/// "lldb/Expression/ExpressionVariable.h"
117/// A list of variable references.
118///
119/// This class stores variables internally, acting as the permanent store.
121public:
122 /// Implementation of methods in ExpressionVariableListBase
123 size_t GetSize() { return m_variables.size(); }
124
125 lldb::ExpressionVariableSP GetVariableAtIndex(size_t index) {
126 lldb::ExpressionVariableSP var_sp;
127 if (index < m_variables.size())
128 var_sp = m_variables[index];
129 return var_sp;
130 }
131
132 size_t AddVariable(const lldb::ExpressionVariableSP &var_sp) {
133 m_variables.push_back(var_sp);
134 return m_variables.size() - 1;
135 }
136
137 lldb::ExpressionVariableSP
139 lldb::ExpressionVariableSP var_sp(var);
140 m_variables.push_back(var_sp);
141 return m_variables.back();
142 }
143
144 bool ContainsVariable(const lldb::ExpressionVariableSP &var_sp) {
145 const size_t size = m_variables.size();
146 for (size_t index = 0; index < size; ++index) {
147 if (m_variables[index].get() == var_sp.get())
148 return true;
149 }
150 return false;
151 }
152
153 /// Finds a variable by name in the list.
154 ///
155 /// \param[in] name
156 /// The name of the requested variable.
157 ///
158 /// \return
159 /// The variable requested, or nullptr if that variable is not in the
160 /// list.
161 lldb::ExpressionVariableSP GetVariable(ConstString name) {
162 lldb::ExpressionVariableSP var_sp;
163 for (size_t index = 0, size = GetSize(); index < size; ++index) {
164 var_sp = GetVariableAtIndex(index);
165 if (var_sp->GetName() == name)
166 return var_sp;
167 }
168 var_sp.reset();
169 return var_sp;
170 }
171
172 lldb::ExpressionVariableSP GetVariable(llvm::StringRef name) {
173 if (name.empty())
174 return nullptr;
175
176 for (size_t index = 0, size = GetSize(); index < size; ++index) {
177 auto var_sp = GetVariableAtIndex(index);
178 llvm::StringRef var_name_str = var_sp->GetName().GetStringRef();
179 if (var_name_str == name)
180 return var_sp;
181 }
182 return nullptr;
183 }
184
185 void RemoveVariable(lldb::ExpressionVariableSP var_sp) {
186 for (std::vector<lldb::ExpressionVariableSP>::iterator
187 vi = m_variables.begin(),
188 ve = m_variables.end();
189 vi != ve; ++vi) {
190 if (vi->get() == var_sp.get()) {
191 m_variables.erase(vi);
192 return;
193 }
194 }
195 }
196
197 void Clear() { m_variables.clear(); }
198
199private:
200 std::vector<lldb::ExpressionVariableSP> m_variables;
201};
202
204public:
205 // See TypeSystem.h for how to add subclasses to this.
207
208 LLVMCastKind getKind() const { return m_kind; }
209
212
213 virtual lldb::ExpressionVariableSP
214 CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) = 0;
215
216 virtual lldb::ExpressionVariableSP
218 ConstString name, const CompilerType &type,
219 lldb::ByteOrder byte_order,
220 uint32_t addr_byte_size) = 0;
221
222 /// Return a new persistent variable name with the specified prefix.
223 virtual ConstString GetNextPersistentVariableName(bool is_error = false) = 0;
224
225 virtual void
226 RemovePersistentVariable(lldb::ExpressionVariableSP variable) = 0;
227
228 virtual std::optional<CompilerType>
230
232
233 void RegisterExecutionUnit(lldb::IRExecutionUnitSP &execution_unit_sp);
234
235protected:
236 virtual llvm::StringRef
237 GetPersistentVariablePrefix(bool is_error = false) const = 0;
238
239private:
241
242 typedef std::set<lldb::IRExecutionUnitSP> ExecutionUnitSet;
244 m_execution_units; ///< The execution units that contain valuable symbols.
245
246 typedef llvm::DenseMap<const char *, lldb::addr_t> SymbolMap;
248 m_symbol_map; ///< The addresses of the symbols in m_execution_units.
249};
250
251} // namespace lldb_private
252
253#endif // LLDB_EXPRESSION_EXPRESSIONVARIABLE_H
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
A uniqued constant string class.
Definition: ConstString.h:39
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Expression/ExpressionVariable.h" A list of variable references.
lldb::ExpressionVariableSP GetVariable(llvm::StringRef name)
lldb::ExpressionVariableSP AddNewlyConstructedVariable(ExpressionVariable *var)
size_t GetSize()
Implementation of methods in ExpressionVariableListBase.
std::vector< lldb::ExpressionVariableSP > m_variables
lldb::ExpressionVariableSP GetVariableAtIndex(size_t index)
lldb::ExpressionVariableSP GetVariable(ConstString name)
Finds a variable by name in the list.
size_t AddVariable(const lldb::ExpressionVariableSP &var_sp)
void RemoveVariable(lldb::ExpressionVariableSP var_sp)
bool ContainsVariable(const lldb::ExpressionVariableSP &var_sp)
lldb::ValueObjectSP GetValueObject()
std::optional< uint64_t > GetByteSize()
void TransferAddress(bool force=false)
void SetRegisterInfo(const RegisterInfo *reg_info)
void SetCompilerType(const CompilerType &compiler_type)
@ EVTypeIsReference
The original type of this variable is a reference, so materialize the value rather than the location.
@ EVIsLLDBAllocated
This variable is resident in a location specifically allocated for it by LLDB in the target process.
@ EVNeedsFreezeDry
Copy from m_live_sp to m_frozen_sp during dematerialization.
@ EVNeedsAllocation
Space for this variable has yet to be allocated in the target process.
@ EVIsProgramReference
This variable is a reference to a (possibly invalid) area managed by the target program.
@ EVIsFreezeDried
This variable's authoritative version is in m_frozen_sp (for example, for statically-computed results...
@ EVBareRegister
This variable is a direct reference to $pc or some other entity.
@ EVKeepInTarget
Keep the allocation after the expression is complete rather than freeze drying its contents and freei...
virtual void RemovePersistentVariable(lldb::ExpressionVariableSP variable)=0
virtual lldb::ExpressionVariableSP CreatePersistentVariable(ExecutionContextScope *exe_scope, ConstString name, const CompilerType &type, lldb::ByteOrder byte_order, uint32_t addr_byte_size)=0
virtual llvm::StringRef GetPersistentVariablePrefix(bool is_error=false) const =0
llvm::DenseMap< const char *, lldb::addr_t > SymbolMap
virtual std::optional< CompilerType > GetCompilerTypeFromPersistentDecl(ConstString type_name)=0
void RegisterExecutionUnit(lldb::IRExecutionUnitSP &execution_unit_sp)
virtual lldb::ExpressionVariableSP CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp)=0
std::set< lldb::IRExecutionUnitSP > ExecutionUnitSet
ExecutionUnitSet m_execution_units
The execution units that contain valuable symbols.
SymbolMap m_symbol_map
The addresses of the symbols in m_execution_units.
virtual ConstString GetNextPersistentVariableName(bool is_error=false)=0
Return a new persistent variable name with the specified prefix.
virtual lldb::addr_t LookupSymbol(ConstString name)
@ RegisterInfo
RegisterInfo * (can be a scalar or a vector register).
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
ByteOrder
Byte ordering definitions.
uint64_t addr_t
Definition: lldb-types.h:79