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