LLDB mainline
SBFrame.h
Go to the documentation of this file.
1//===-- SBFrame.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_API_SBFRAME_H
10#define LLDB_API_SBFRAME_H
11
12#include "lldb/API/SBDefines.h"
14
15namespace lldb {
16
18public:
19 SBFrame();
20
21 SBFrame(const lldb::SBFrame &rhs);
22
23 const lldb::SBFrame &operator=(const lldb::SBFrame &rhs);
24
26
27 bool IsEqual(const lldb::SBFrame &that) const;
28
29 explicit operator bool() const;
30
31 bool IsValid() const;
32
33 uint32_t GetFrameID() const;
34
35 lldb::addr_t GetCFA() const;
36
37 lldb::addr_t GetPC() const;
38
39 bool SetPC(lldb::addr_t new_pc);
40
41 lldb::addr_t GetSP() const;
42
43 lldb::addr_t GetFP() const;
44
45 lldb::SBAddress GetPCAddress() const;
46
47 lldb::SBSymbolContext GetSymbolContext(uint32_t resolve_scope) const;
48
49 lldb::SBModule GetModule() const;
50
51 lldb::SBCompileUnit GetCompileUnit() const;
52
53 lldb::SBFunction GetFunction() const;
54
55 lldb::SBSymbol GetSymbol() const;
56
57 /// Gets the deepest block that contains the frame PC.
58 ///
59 /// See also GetFrameBlock().
60 lldb::SBBlock GetBlock() const;
61
62 /// Get the appropriate function name for this frame. Inlined functions in
63 /// LLDB are represented by Blocks that have inlined function information, so
64 /// just looking at the SBFunction or SBSymbol for a frame isn't enough.
65 /// This function will return the appropriate function, symbol or inlined
66 /// function name for the frame.
67 ///
68 /// This function returns:
69 /// - the name of the inlined function (if there is one)
70 /// - the name of the concrete function (if there is one)
71 /// - the name of the symbol (if there is one)
72 /// - NULL
73 ///
74 /// See also IsInlined().
75 const char *GetFunctionName();
76
77 // Get an appropriate function name for this frame that is suitable for
78 // display to a user
79 const char *GetDisplayFunctionName();
80
81 const char *GetFunctionName() const;
82
83 // Return the frame function's language. If there isn't a function, then
84 // guess the language type from the mangled name.
85 lldb::LanguageType GuessLanguage() const;
86
87 /// Return true if this frame represents an inlined function.
88 ///
89 /// See also GetFunctionName().
90 bool IsInlined();
91
92 bool IsInlined() const;
93
94 bool IsArtificial();
95
96 bool IsArtificial() const;
97
98 /// The version that doesn't supply a 'use_dynamic' value will use the
99 /// target's default.
100 lldb::SBValue EvaluateExpression(const char *expr);
101
102 lldb::SBValue EvaluateExpression(const char *expr,
103 lldb::DynamicValueType use_dynamic);
104
105 lldb::SBValue EvaluateExpression(const char *expr,
106 lldb::DynamicValueType use_dynamic,
107 bool unwind_on_error);
108
109 lldb::SBValue EvaluateExpression(const char *expr,
110 const SBExpressionOptions &options);
111
112 /// Gets the lexical block that defines the stack frame. Another way to think
113 /// of this is it will return the block that contains all of the variables
114 /// for a stack frame. Inlined functions are represented as SBBlock objects
115 /// that have inlined function information: the name of the inlined function,
116 /// where it was called from. The block that is returned will be the first
117 /// block at or above the block for the PC (SBFrame::GetBlock()) that defines
118 /// the scope of the frame. When a function contains no inlined functions,
119 /// this will be the top most lexical block that defines the function.
120 /// When a function has inlined functions and the PC is currently
121 /// in one of those inlined functions, this method will return the inlined
122 /// block that defines this frame. If the PC isn't currently in an inlined
123 /// function, the lexical block that defines the function is returned.
124 lldb::SBBlock GetFrameBlock() const;
125
126 lldb::SBLineEntry GetLineEntry() const;
127
128 lldb::SBThread GetThread() const;
129
130 const char *Disassemble() const;
131
132 void Clear();
133
134 bool operator==(const lldb::SBFrame &rhs) const;
135
136 bool operator!=(const lldb::SBFrame &rhs) const;
137
138 /// The version that doesn't supply a 'use_dynamic' value will use the
139 /// target's default.
140 lldb::SBValueList GetVariables(bool arguments, bool locals, bool statics,
141 bool in_scope_only);
142
143 lldb::SBValueList GetVariables(bool arguments, bool locals, bool statics,
144 bool in_scope_only,
145 lldb::DynamicValueType use_dynamic);
146
147 lldb::SBValueList GetVariables(const lldb::SBVariablesOptions &options);
148
149 lldb::SBValueList GetRegisters();
150
151 lldb::SBValue FindRegister(const char *name);
152
153 /// The version that doesn't supply a 'use_dynamic' value will use the
154 /// target's default.
155 lldb::SBValue FindVariable(const char *var_name);
156
157 lldb::SBValue FindVariable(const char *var_name,
158 lldb::DynamicValueType use_dynamic);
159
160 // Find a value for a variable expression path like "rect.origin.x" or
161 // "pt_ptr->x", "*self", "*this->obj_ptr". The returned value is _not_ and
162 // expression result and is not a constant object like
163 // SBFrame::EvaluateExpression(...) returns, but a child object of the
164 // variable value.
165 lldb::SBValue GetValueForVariablePath(const char *var_expr_cstr,
166 DynamicValueType use_dynamic);
167
168 /// The version that doesn't supply a 'use_dynamic' value will use the
169 /// target's default.
170 lldb::SBValue GetValueForVariablePath(const char *var_path);
171
172 /// Find variables, register sets, registers, or persistent variables using
173 /// the frame as the scope.
174 ///
175 /// NB. This function does not look up ivars in the function object pointer.
176 /// To do that use GetValueForVariablePath.
177 ///
178 /// The version that doesn't supply a 'use_dynamic' value will use the
179 /// target's default.
180 lldb::SBValue FindValue(const char *name, ValueType value_type);
181
182 lldb::SBValue FindValue(const char *name, ValueType value_type,
183 lldb::DynamicValueType use_dynamic);
184
185 bool GetDescription(lldb::SBStream &description);
186
187#ifndef SWIG
188 SBFrame(const lldb::StackFrameSP &lldb_object_sp);
189#endif
190
191protected:
192 friend class SBBlock;
193 friend class SBExecutionContext;
194 friend class SBInstruction;
195 friend class SBThread;
196 friend class SBValue;
197
198 lldb::StackFrameSP GetFrameSP() const;
199
200 void SetFrameSP(const lldb::StackFrameSP &lldb_object_sp);
201
202 lldb::ExecutionContextRefSP m_opaque_sp;
203};
204
205} // namespace lldb
206
207#endif // LLDB_API_SBFRAME_H
bool operator!=(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs)
bool operator==(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs)
#define LLDB_API
Definition: SBDefines.h:26
lldb::ExecutionContextRefSP m_opaque_sp
Definition: SBFrame.h:202
SBFrame(const lldb::StackFrameSP &lldb_object_sp)
Definition: SBAddress.h:15
LanguageType
Programming language type.
uint64_t addr_t
Definition: lldb-types.h:79