SBFrame#

class lldb.SBFrame(*args)#

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.

Attributes Summary

`addr`	A read only property that returns the program counter (PC) as a section offset address (lldb.SBAddress).
`args`	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`	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.
`block`	A read only property that returns an lldb object that represents the block (lldb.SBBlock) for this stack frame.
`compile_unit`	A read only property that returns an lldb object that represents the compile unit (lldb.SBCompileUnit) for this stack frame.
`disassembly`	A read only property that returns the disassembly for this stack frame as a python string.
`fp`	A read only property that returns the frame pointer (FP) as an unsigned integer.
`function`	A read only property that returns an lldb object that represents the function (lldb.SBFunction) for this stack frame.
`idx`	A read only property that returns the zero based stack frame index.
`is_inlined`	A read only property that returns an boolean that indicates if the block frame is an inlined function.
`line_entry`	A read only property that returns an lldb object that represents the line table entry (lldb.SBLineEntry) for this stack frame.
`locals`	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.
`module`	A read only property that returns an lldb object that represents the module (lldb.SBModule) for this stack frame.
`name`	A read only property that retuns the name for the function that this frame represents.
`parent`	A read only property that returns the parent (caller) frame of the current frame.
`pc`	GetPC(SBFrame self) -> lldb::addr_t
`reg`	A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame
`register`	A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame.
`registers`	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`	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.
`sp`	A read only property that returns the stack pointer (SP) as an unsigned integer.
`statics`	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.
`symbol`	A read only property that returns an lldb object that represents the symbol (lldb.SBSymbol) for this stack frame.
`thread`	A read only property that returns an lldb object that represents the thread (lldb.SBThread) for this stack frame.
`variables`	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`	A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.

Methods Summary

`Clear`(SBFrame self)
`Disassemble`(SBFrame self)
`EvaluateExpression`(...)	The version that doesn't supply a 'use_dynamic' value will use the target's default.
`FindRegister`(SBFrame self, char const * name)
`FindValue`(-> SBValue)	Find variables, register sets, registers, or persistent variables using the frame as the scope.
`FindVariable`(-> SBValue)	The version that doesn't supply a 'use_dynamic' value will use the target's default.
`GetBlock`(SBFrame self)	Gets the deepest block that contains the frame PC.
`GetCFA`(SBFrame self)	Get the Canonical Frame Address for this stack frame.
`GetCompileUnit`(SBFrame self)
`GetDescription`(SBFrame self, ...)
`GetDescriptionWithFormat`(SBFrame self, ...)
`GetDisplayFunctionName`(SBFrame self)
`GetFP`(SBFrame self)
`GetFrameBlock`(SBFrame self)	Gets the lexical block that defines the stack frame.
`GetFrameID`(SBFrame self)
`GetFunction`(SBFrame self)
`GetFunctionName`(-> char const)	Get the appropriate function name for this frame.
`GetLineEntry`(SBFrame self)
`GetModule`(SBFrame self)
`GetPC`(SBFrame self)
`GetPCAddress`(SBFrame self)
`GetRegisters`(SBFrame self)
`GetSP`(SBFrame self)
`GetSymbol`(SBFrame self)
`GetSymbolContext`(SBFrame self, ...)
`GetThread`(SBFrame self)
`GetValueForVariablePath`(-> SBValue)	Get a lldb.SBValue for a variable path.
`GetVariables`(-> SBValueList -> SBValueList)	The version that doesn't supply a 'use_dynamic' value will use the target's default.
`GuessLanguage`(SBFrame self)	Returns the language of the frame's SBFunction, or if there.
`IsArtificial`(-> bool)	Return true if this frame is artificial (e.g a frame synthesized to capture a tail call).
`IsEqual`(SBFrame self, SBFrame that)
`IsInlined`(-> bool)	Return true if this frame represents an inlined function.
`IsValid`(SBFrame self)
`SetPC`(SBFrame self, lldb)
`get_all_variables`()
`get_arguments`()
`get_locals`()
`get_parent_frame`()
`get_registers_access`()
`get_statics`()
`var`(var_expr_path)	Calls through to lldb.SBFrame.GetValueForVariablePath() and returns a value that represents the variable expression path

Attributes Documentation

addr#: A read only property that returns the program counter (PC) as a section offset address (lldb.SBAddress).

args#: 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#: 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.

block#: A read only property that returns an lldb object that represents the block (lldb.SBBlock) for this stack frame.

compile_unit#: A read only property that returns an lldb object that represents the compile unit (lldb.SBCompileUnit) for this stack frame.

disassembly#: A read only property that returns the disassembly for this stack frame as a python string.

fp#: A read only property that returns the frame pointer (FP) as an unsigned integer.

function#: A read only property that returns an lldb object that represents the function (lldb.SBFunction) for this stack frame.

idx#: A read only property that returns the zero based stack frame index.

is_inlined#: A read only property that returns an boolean that indicates if the block frame is an inlined function.

line_entry#: A read only property that returns an lldb object that represents the line table entry (lldb.SBLineEntry) for this stack frame.

locals#: 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.

module#: A read only property that returns an lldb object that represents the module (lldb.SBModule) for this stack frame.

name#: 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).

parent#: A read only property that returns the parent (caller) frame of the current frame.

pc#: GetPC(SBFrame self) -> lldb::addr_t

reg#: A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame

register#: A read only property that returns an helper object providing a flattened indexable view of the CPU registers for this stack frame.

registers#: 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#: 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.

sp#: A read only property that returns the stack pointer (SP) as an unsigned integer.

statics#: 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.

symbol#: A read only property that returns an lldb object that represents the symbol (lldb.SBSymbol) for this stack frame.

thread#: A read only property that returns an lldb object that represents the thread (lldb.SBThread) for this stack frame.

variables#: 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#: A read only property that returns a list() that contains a collection of lldb.SBValue objects that represent the variables in this stack frame.

Methods Documentation

Clear(SBFrame self)#

Disassemble(SBFrame self) → char const *#

EvaluateExpression(SBFrame self, char const * expr) → SBValue#
EvaluateExpression(SBFrame self, char const * expr, lldb::DynamicValueType use_dynamic) → SBValue
EvaluateExpression(SBFrame self, char const * expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error) → SBValue
EvaluateExpression(SBFrame self, char const * expr, SBExpressionOptions options) → SBValue: The version that doesn’t supply a ‘use_dynamic’ value will use the target’s default.

FindRegister(SBFrame self, char const * name) → SBValue#

FindValue(SBFrame self, char const * name, lldb::ValueType value_type) → SBValue#

FindValue(SBFrame self, char const * name, lldb::ValueType value_type, lldb::DynamicValueType use_dynamic) → SBValue

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.

FindVariable(SBFrame self, char const * var_name) → SBValue#
FindVariable(SBFrame self, char const * var_name, lldb::DynamicValueType use_dynamic) → SBValue: The version that doesn’t supply a ‘use_dynamic’ value will use the target’s default.

GetBlock(SBFrame self) → SBBlock#

Gets the deepest block that contains the frame PC.