summaryrefslogtreecommitdiff
path: root/lldb/bindings/interface/SBFrame.i
diff options
context:
space:
mode:
Diffstat (limited to 'lldb/bindings/interface/SBFrame.i')
-rw-r--r--lldb/bindings/interface/SBFrame.i364
1 files changed, 364 insertions, 0 deletions
diff --git a/lldb/bindings/interface/SBFrame.i b/lldb/bindings/interface/SBFrame.i
new file mode 100644
index 0000000000000..c65b88f863e7d
--- /dev/null
+++ b/lldb/bindings/interface/SBFrame.i
@@ -0,0 +1,364 @@
+//===-- 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);
+
+ STRING_EXTENSION(SBFrame)
+
+#ifdef SWIGPYTHON
+ %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.''')
+ %}
+#endif
+};
+
+} // namespace lldb