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
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
| //===-- SWIG Interface for SBFrame ------------------------------*- 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
//
//===----------------------------------------------------------------------===//
namespace lldb {
%feature("docstring",
"Represents one of the stack frames associated with a thread.
SBThread contains SBFrame(s). For example (from test/lldbutil.py),
def print_stacktrace(thread, string_buffer = False):
'''Prints a simple stack trace of this thread.'''
...
for i in range(depth):
frame = thread.GetFrameAtIndex(i)
function = frame.GetFunction()
load_addr = addrs[i].GetLoadAddress(target)
if not function:
file_addr = addrs[i].GetFileAddress()
start_addr = frame.GetSymbol().GetStartAddress().GetFileAddress()
symbol_offset = file_addr - start_addr
print >> output, ' frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format(
num=i, addr=load_addr, mod=mods[i], symbol=symbols[i], offset=symbol_offset)
else:
print >> output, ' frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format(
num=i, addr=load_addr, mod=mods[i],
func='%s [inlined]' % funcs[i] if frame.IsInlined() else funcs[i],
file=files[i], line=lines[i],
args=get_args_as_string(frame, showFuncName=False) if not frame.IsInlined() else '()')
...
And,
for frame in thread:
print frame
See also SBThread."
) SBFrame;
class SBFrame
{
public:
SBFrame ();
SBFrame (const lldb::SBFrame &rhs);
~SBFrame();
bool
IsEqual (const lldb::SBFrame &rhs) const;
bool
IsValid() const;
explicit operator bool() const;
uint32_t
GetFrameID () const;
%feature("docstring", "
Get the Canonical Frame Address for this stack frame.
This is the DWARF standard's definition of a CFA, a stack address
that remains constant throughout the lifetime of the function.
Returns an lldb::addr_t stack address, or LLDB_INVALID_ADDRESS if
the CFA cannot be determined.") GetCFA;
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;
%feature("docstring", "
Gets the deepest block that contains the frame PC.
See also GetFrameBlock().") GetBlock;
lldb::SBBlock
GetBlock () const;
%feature("docstring", "
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().") GetFunctionName;
const char *
GetFunctionName();
const char *
GetDisplayFunctionName ();
const char *
GetFunctionName() const;
%feature("docstring", "
Returns the language of the frame's SBFunction, or if there.
is no SBFunction, guess the language from the mangled name.
.") GuessLanguage;
lldb::LanguageType
GuessLanguage() const;
%feature("docstring", "
Return true if this frame represents an inlined function.
See also GetFunctionName().") IsInlined;
bool
IsInlined();
bool
IsInlined() const;
%feature("docstring", "
Return true if this frame is artificial (e.g a frame synthesized to
capture a tail call). Local variables may not be available in an artificial
frame.") IsArtificial;
bool
IsArtificial();
bool
IsArtificial() const;
%feature("docstring", "
The version that doesn't supply a 'use_dynamic' value will use the
target's default.") EvaluateExpression;
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, SBExpressionOptions &options);
%feature("docstring", "
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.") GetFrameBlock;
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;
%feature("docstring", "
The version that doesn't supply a 'use_dynamic' value will use the
target's default.") GetVariables;
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 ();
%feature("docstring", "
The version that doesn't supply a 'use_dynamic' value will use the
target's default.") FindVariable;
lldb::SBValue
FindVariable (const char *var_name);
lldb::SBValue
FindVariable (const char *var_name, lldb::DynamicValueType use_dynamic);
lldb::SBValue
FindRegister (const char *name);
%feature("docstring", "
Get a lldb.SBValue for a variable path.
Variable paths can include access to pointer or instance members:
rect_ptr->origin.y
pt.x
Pointer dereferences:
*this->foo_ptr
**argv
Address of:
&pt
&my_array[3].x
Array accesses and treating pointers as arrays:
int_array[1]
pt_ptr[22].x
Unlike EvaluateExpression() which returns lldb.SBValue objects
with constant copies of the values at the time of evaluation,
the result of this function is a value that will continue to
track the current value of the value as execution progresses
in the current frame.") GetValueForVariablePath;
lldb::SBValue
GetValueForVariablePath (const char *var_path);
lldb::SBValue
GetValueForVariablePath (const char *var_path, lldb::DynamicValueType use_dynamic);
%feature("docstring", "
Find variables, register sets, registers, or persistent variables using
the frame as the scope.
The version that doesn't supply a 'use_dynamic' value will use the
target's default.") FindValue;
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);
%pythoncode %{
def get_all_variables(self):
return self.GetVariables(True,True,True,True)
def get_parent_frame(self):
parent_idx = self.idx + 1
if parent_idx >= 0 and parent_idx < len(self.thread.frame):
return self.thread.frame[parent_idx]
else:
return SBFrame()
def get_arguments(self):
return self.GetVariables(True,False,False,False)
def get_locals(self):
return self.GetVariables(False,True,False,False)
def get_statics(self):
return self.GetVariables(False,False,True,False)
def var(self, var_expr_path):
'''Calls through to lldb.SBFrame.GetValueForVariablePath() and returns
a value that represents the variable expression path'''
return self.GetValueForVariablePath(var_expr_path)
def get_registers_access(self):
class registers_access(object):
'''A helper object that exposes a flattened view of registers, masking away the notion of register sets for easy scripting.'''
def __init__(self, regs):
self.regs = regs
def __getitem__(self, key):
if type(key) is str:
for i in range(0,len(self.regs)):
rs = self.regs[i]
for j in range (0,rs.num_children):
reg = rs.GetChildAtIndex(j)
if reg.name == key: return reg
else:
return lldb.SBValue()
return registers_access(self.registers)
pc = property(GetPC, SetPC)
addr = property(GetPCAddress, None, doc='''A read only property that returns the program counter (PC) as a section offset address (lldb.SBAddress).''')
fp = property(GetFP, None, doc='''A read only property that returns the frame pointer (FP) as an unsigned integer.''')
sp = property(GetSP, None, doc='''A read only property that returns the stack pointer (SP) as an unsigned integer.''')
module = property(GetModule, None, doc='''A read only property that returns an lldb object that represents the module (lldb.SBModule) for this stack frame.''')
compile_unit = property(GetCompileUnit, None, doc='''A read only property that returns an lldb object that represents the compile unit (lldb.SBCompileUnit) for this stack frame.''')
function = property(GetFunction, None, doc='''A read only property that returns an lldb object that represents the function (lldb.SBFunction) for this stack frame.''')
symbol = property(GetSymbol, None, doc='''A read only property that returns an lldb object that represents the symbol (lldb.SBSymbol) for this stack frame.''')
block = property(GetBlock, None, doc='''A read only property that returns an lldb object that represents the block (lldb.SBBlock) for this stack frame.''')
is_inlined = property(IsInlined, None, doc='''A read only property that returns an boolean that indicates if the block frame is an inlined function.''')
name = property(GetFunctionName, None, doc='''A read only property that retuns the name for the function that this frame represents. Inlined stack frame might have a concrete function that differs from the name of the inlined function (a named lldb.SBBlock).''')
line_entry = property(GetLineEntry, None, doc='''A read only property that returns an lldb object that represents the line table entry (lldb.SBLineEntry) for this stack frame.''')
thread = property(GetThread, None, doc='''A read only property that returns an lldb object that represents the thread (lldb.SBThread) for this stack frame.''')
disassembly = property(Disassemble, None, doc='''A read only property that returns the disassembly for this stack frame as a python string.''')
idx = property(GetFrameID, None, doc='''A read only property that returns the zero based stack frame index.''')
variables = property(get_all_variables, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.''')
vars = property(get_all_variables, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.''')
locals = property(get_locals, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the local variables in this stack frame.''')
args = property(get_arguments, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the argument variables in this stack frame.''')
arguments = property(get_arguments, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the argument variables in this stack frame.''')
statics = property(get_statics, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the static variables in this stack frame.''')
registers = property(GetRegisters, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the CPU registers for this stack frame.''')
regs = property(GetRegisters, None, doc='''A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the CPU registers for this stack frame.''')
register = property(get_registers_access, None, doc='''A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame.''')
reg = property(get_registers_access, None, doc='''A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame''')
parent = property(get_parent_frame, None, doc='''A read only property that returns the parent (caller) frame of the current frame.''')
%}
};
} // namespace lldb
|