1 %feature("docstring", 2 "Represents one of the stack frames associated with a thread. 3 4 SBThread contains SBFrame(s). For example (from test/lldbutil.py), :: 5 6 def print_stacktrace(thread, string_buffer = False): 7 '''Prints a simple stack trace of this thread.''' 8 9 ... 10 11 for i in range(depth): 12 frame = thread.GetFrameAtIndex(i) 13 function = frame.GetFunction() 14 15 load_addr = addrs[i].GetLoadAddress(target) 16 if not function: 17 file_addr = addrs[i].GetFileAddress() 18 start_addr = frame.GetSymbol().GetStartAddress().GetFileAddress() 19 symbol_offset = file_addr - start_addr 20 print >> output, ' frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}'.format( 21 num=i, addr=load_addr, mod=mods[i], symbol=symbols[i], offset=symbol_offset) 22 else: 23 print >> output, ' frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}'.format( 24 num=i, addr=load_addr, mod=mods[i], 25 func='%s [inlined]' % funcs[i] if frame.IsInlined() else funcs[i], 26 file=files[i], line=lines[i], 27 args=get_args_as_string(frame, showFuncName=False) if not frame.IsInlined() else '()') 28 29 ... 30 31 And, :: 32 33 for frame in thread: 34 print frame 35 36 See also SBThread." 37 ) lldb::SBFrame; 38 39 %feature("docstring", " 40 Get the Canonical Frame Address for this stack frame. 41 This is the DWARF standard's definition of a CFA, a stack address 42 that remains constant throughout the lifetime of the function. 43 Returns an lldb::addr_t stack address, or LLDB_INVALID_ADDRESS if 44 the CFA cannot be determined." 45 ) lldb::SBFrame::GetCFA; 46 47 %feature("docstring", " 48 Gets the deepest block that contains the frame PC. 49 50 See also GetFrameBlock()." 51 ) lldb::SBFrame::GetBlock; 52 53 %feature("docstring", " 54 Get the appropriate function name for this frame. Inlined functions in 55 LLDB are represented by Blocks that have inlined function information, so 56 just looking at the SBFunction or SBSymbol for a frame isn't enough. 57 This function will return the appropriate function, symbol or inlined 58 function name for the frame. 59 60 This function returns: 61 - the name of the inlined function (if there is one) 62 - the name of the concrete function (if there is one) 63 - the name of the symbol (if there is one) 64 - NULL 65 66 See also IsInlined()." 67 ) lldb::SBFrame::GetFunctionName; 68 69 %feature("docstring", " 70 Returns the language of the frame's SBFunction, or if there. 71 is no SBFunction, guess the language from the mangled name. 72 ." 73 ) lldb::SBFrame::GuessLanguage; 74 75 %feature("docstring", " 76 Return true if this frame represents an inlined function. 77 78 See also GetFunctionName()." 79 ) lldb::SBFrame::IsInlined; 80 81 %feature("docstring", " 82 Return true if this frame is artificial (e.g a frame synthesized to 83 capture a tail call). Local variables may not be available in an artificial 84 frame." 85 ) lldb::SBFrame::IsArtificial; 86 87 %feature("docstring", " 88 The version that doesn't supply a 'use_dynamic' value will use the 89 target's default." 90 ) lldb::SBFrame::EvaluateExpression; 91 92 %feature("docstring", " 93 Gets the lexical block that defines the stack frame. Another way to think 94 of this is it will return the block that contains all of the variables 95 for a stack frame. Inlined functions are represented as SBBlock objects 96 that have inlined function information: the name of the inlined function, 97 where it was called from. The block that is returned will be the first 98 block at or above the block for the PC (SBFrame::GetBlock()) that defines 99 the scope of the frame. When a function contains no inlined functions, 100 this will be the top most lexical block that defines the function. 101 When a function has inlined functions and the PC is currently 102 in one of those inlined functions, this method will return the inlined 103 block that defines this frame. If the PC isn't currently in an inlined 104 function, the lexical block that defines the function is returned." 105 ) lldb::SBFrame::GetFrameBlock; 106 107 %feature("docstring", " 108 The version that doesn't supply a 'use_dynamic' value will use the 109 target's default." 110 ) lldb::SBFrame::GetVariables; 111 112 %feature("docstring", " 113 The version that doesn't supply a 'use_dynamic' value will use the 114 target's default." 115 ) lldb::SBFrame::FindVariable; 116 117 %feature("docstring", " 118 Get a lldb.SBValue for a variable path. 119 120 Variable paths can include access to pointer or instance members: :: 121 122 rect_ptr->origin.y 123 pt.x 124 125 Pointer dereferences: :: 126 127 *this->foo_ptr 128 **argv 129 130 Address of: :: 131 132 &pt 133 &my_array[3].x 134 135 Array accesses and treating pointers as arrays: :: 136 137 int_array[1] 138 pt_ptr[22].x 139 140 Unlike `EvaluateExpression()` which returns :py:class:`SBValue` objects 141 with constant copies of the values at the time of evaluation, 142 the result of this function is a value that will continue to 143 track the current value of the value as execution progresses 144 in the current frame." 145 ) lldb::SBFrame::GetValueForVariablePath; 146 147 %feature("docstring", " 148 Find variables, register sets, registers, or persistent variables using 149 the frame as the scope. 150 151 The version that doesn't supply a ``use_dynamic`` value will use the 152 target's default." 153 ) lldb::SBFrame::FindValue; 154