Module _lldb'

[frames] | no frames]

Module _lldb'

Functions

[hide private]

SBAddress_Clear(...)
SBAddress_Clear(SBAddress self)

SBAddress_GetAddressClass(...)
SBAddress_GetAddressClass(SBAddress self) -> lldb::AddressClass

SBAddress_GetBlock(...)
SBAddress_GetBlock(SBAddress self) -> SBBlock

SBAddress_GetCompileUnit(...)
SBAddress_GetCompileUnit(SBAddress self) -> SBCompileUnit

SBAddress_GetDescription(...)
SBAddress_GetDescription(SBAddress self, SBStream description) -> bool

SBAddress_GetFileAddress(...)
SBAddress_GetFileAddress(SBAddress self) -> lldb::addr_t

SBAddress_GetFunction(...)
SBAddress_GetFunction(SBAddress self) -> SBFunction

SBAddress_GetLineEntry(...)
SBAddress_GetLineEntry(SBAddress self) -> SBLineEntry

SBAddress_GetLoadAddress(...)
SBAddress_GetLoadAddress(SBAddress self, SBTarget target) -> lldb::addr_t

SBAddress_GetModule(...)
SBAddress_GetModule(SBAddress self) -> SBModule

SBAddress_GetOffset(...)
SBAddress_GetOffset(SBAddress self) -> lldb::addr_t

SBAddress_GetSection(...)
SBAddress_GetSection(SBAddress self) -> SBSection

SBAddress_GetSymbol(...)
SBAddress_GetSymbol(SBAddress self) -> SBSymbol

SBAddress_GetSymbolContext(...)
SBAddress_GetSymbolContext(SBAddress self, uint32_t resolve_scope) -> SBSymbolContext

SBAddress_IsValid(...)
SBAddress_IsValid(SBAddress self) -> bool

SBAddress_OffsetAddress(...)
SBAddress_OffsetAddress(SBAddress self, lldb::addr_t offset) -> bool

SBAddress_SetAddress(...)
SBAddress_SetAddress(SBAddress self, SBSection section, lldb::addr_t offset)

SBAddress_SetLoadAddress(...)
SBAddress_SetLoadAddress(SBAddress self, lldb::addr_t load_addr, SBTarget target)

SBAddress___str__(...)
SBAddress___str__(SBAddress self) -> PyObject *

SBAddress_swigregister(...)

SBAttachInfo_EffectiveGroupIDIsValid(...)
SBAttachInfo_EffectiveGroupIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_EffectiveUserIDIsValid(...)
SBAttachInfo_EffectiveUserIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_GetEffectiveGroupID(...)
SBAttachInfo_GetEffectiveGroupID(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetEffectiveUserID(...)
SBAttachInfo_GetEffectiveUserID(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetGroupID(...)
SBAttachInfo_GetGroupID(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetIgnoreExisting(...)
SBAttachInfo_GetIgnoreExisting(SBAttachInfo self) -> bool

SBAttachInfo_GetParentProcessID(...)
SBAttachInfo_GetParentProcessID(SBAttachInfo self) -> lldb::pid_t

SBAttachInfo_GetProcessID(...)
SBAttachInfo_GetProcessID(SBAttachInfo self) -> lldb::pid_t

SBAttachInfo_GetProcessPluginName(...)
SBAttachInfo_GetProcessPluginName(SBAttachInfo self) -> char const *

SBAttachInfo_GetResumeCount(...)
SBAttachInfo_GetResumeCount(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetUserID(...)
SBAttachInfo_GetUserID(SBAttachInfo self) -> uint32_t

SBAttachInfo_GetWaitForLaunch(...)
SBAttachInfo_GetWaitForLaunch(SBAttachInfo self) -> bool

SBAttachInfo_GroupIDIsValid(...)
SBAttachInfo_GroupIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_ParentProcessIDIsValid(...)
SBAttachInfo_ParentProcessIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_SetEffectiveGroupID(...)
SBAttachInfo_SetEffectiveGroupID(SBAttachInfo self, uint32_t gid)

SBAttachInfo_SetEffectiveUserID(...)
SBAttachInfo_SetEffectiveUserID(SBAttachInfo self, uint32_t uid)

SBAttachInfo_SetExecutable(...)
SetExecutable(char const * path) SBAttachInfo_SetExecutable(SBAttachInfo self, SBFileSpec exe_file)

SBAttachInfo_SetGroupID(...)
SBAttachInfo_SetGroupID(SBAttachInfo self, uint32_t gid)

SBAttachInfo_SetIgnoreExisting(...)
SBAttachInfo_SetIgnoreExisting(SBAttachInfo self, bool b)

SBAttachInfo_SetParentProcessID(...)
SBAttachInfo_SetParentProcessID(SBAttachInfo self, lldb::pid_t pid)

SBAttachInfo_SetProcessID(...)
SBAttachInfo_SetProcessID(SBAttachInfo self, lldb::pid_t pid)

SBAttachInfo_SetProcessPluginName(...)
SBAttachInfo_SetProcessPluginName(SBAttachInfo self, char const * plugin_name)

SBAttachInfo_SetResumeCount(...)
SBAttachInfo_SetResumeCount(SBAttachInfo self, uint32_t c)

SBAttachInfo_SetUserID(...)
SBAttachInfo_SetUserID(SBAttachInfo self, uint32_t uid)

SBAttachInfo_SetWaitForLaunch(...)
SBAttachInfo_SetWaitForLaunch(SBAttachInfo self, bool b)

SBAttachInfo_UserIDIsValid(...)
SBAttachInfo_UserIDIsValid(SBAttachInfo self) -> bool

SBAttachInfo_swigregister(...)

SBBlock_GetContainingInlinedBlock(...)
SBBlock_GetContainingInlinedBlock(SBBlock self) -> SBBlock

SBBlock_GetDescription(...)
SBBlock_GetDescription(SBBlock self, SBStream description) -> bool

SBBlock_GetFirstChild(...)
SBBlock_GetFirstChild(SBBlock self) -> SBBlock

SBBlock_GetInlinedCallSiteColumn(...)
SBBlock_GetInlinedCallSiteColumn(SBBlock self) -> uint32_t

SBBlock_GetInlinedCallSiteFile(...)
SBBlock_GetInlinedCallSiteFile(SBBlock self) -> SBFileSpec

SBBlock_GetInlinedCallSiteLine(...)
SBBlock_GetInlinedCallSiteLine(SBBlock self) -> uint32_t

SBBlock_GetInlinedName(...)
SBBlock_GetInlinedName(SBBlock self) -> char const *

SBBlock_GetNumRanges(...)
SBBlock_GetNumRanges(SBBlock self) -> uint32_t

SBBlock_GetParent(...)
SBBlock_GetParent(SBBlock self) -> SBBlock

SBBlock_GetRangeEndAddress(...)
SBBlock_GetRangeEndAddress(SBBlock self, uint32_t idx) -> SBAddress

SBBlock_GetRangeIndexForBlockAddress(...)
SBBlock_GetRangeIndexForBlockAddress(SBBlock self, SBAddress block_addr) -> uint32_t

SBBlock_GetRangeStartAddress(...)
SBBlock_GetRangeStartAddress(SBBlock self, uint32_t idx) -> SBAddress

SBBlock_GetSibling(...)
SBBlock_GetSibling(SBBlock self) -> SBBlock

SBBlock_GetVariables(...)
GetVariables(SBFrame frame, bool arguments, bool locals, bool statics, lldb::DynamicValueType use_dynamic) -> SBValueList SBBlock_GetVariables(SBBlock self, SBTarget target, bool arguments, bool locals, bool statics) -> SBValueList

SBBlock_IsInlined(...)
SBBlock_IsInlined(SBBlock self) -> bool

SBBlock_IsValid(...)
SBBlock_IsValid(SBBlock self) -> bool

SBBlock___str__(...)
SBBlock___str__(SBBlock self) -> PyObject *

SBBlock_swigregister(...)

SBBreakpointLocation_GetAddress(...)
SBBreakpointLocation_GetAddress(SBBreakpointLocation self) -> SBAddress

SBBreakpointLocation_GetBreakpoint(...)
SBBreakpointLocation_GetBreakpoint(SBBreakpointLocation self) -> SBBreakpoint

SBBreakpointLocation_GetCondition(...)
SBBreakpointLocation_GetCondition(SBBreakpointLocation self) -> char const *

SBBreakpointLocation_GetDescription(...)
SBBreakpointLocation_GetDescription(SBBreakpointLocation self, SBStream description, lldb::DescriptionLevel level) -> bool

SBBreakpointLocation_GetID(...)
SBBreakpointLocation_GetID(SBBreakpointLocation self) -> lldb::break_id_t

SBBreakpointLocation_GetIgnoreCount(...)
SBBreakpointLocation_GetIgnoreCount(SBBreakpointLocation self) -> uint32_t

SBBreakpointLocation_GetLoadAddress(...)
SBBreakpointLocation_GetLoadAddress(SBBreakpointLocation self) -> lldb::addr_t

SBBreakpointLocation_GetQueueName(...)
SBBreakpointLocation_GetQueueName(SBBreakpointLocation self) -> char const *

SBBreakpointLocation_GetThreadID(...)
SBBreakpointLocation_GetThreadID(SBBreakpointLocation self) -> lldb::tid_t

SBBreakpointLocation_GetThreadIndex(...)
SBBreakpointLocation_GetThreadIndex(SBBreakpointLocation self) -> uint32_t

SBBreakpointLocation_GetThreadName(...)
SBBreakpointLocation_GetThreadName(SBBreakpointLocation self) -> char const *

SBBreakpointLocation_IsEnabled(...)
SBBreakpointLocation_IsEnabled(SBBreakpointLocation self) -> bool

SBBreakpointLocation_IsResolved(...)
SBBreakpointLocation_IsResolved(SBBreakpointLocation self) -> bool

SBBreakpointLocation_IsValid(...)
SBBreakpointLocation_IsValid(SBBreakpointLocation self) -> bool

SBBreakpointLocation_SetCondition(...)
SBBreakpointLocation_SetCondition(SBBreakpointLocation self, char const * condition)

SBBreakpointLocation_SetEnabled(...)
SBBreakpointLocation_SetEnabled(SBBreakpointLocation self, bool enabled)

SBBreakpointLocation_SetIgnoreCount(...)
SBBreakpointLocation_SetIgnoreCount(SBBreakpointLocation self, uint32_t n)

SBBreakpointLocation_SetQueueName(...)
SBBreakpointLocation_SetQueueName(SBBreakpointLocation self, char const * queue_name)

SBBreakpointLocation_SetThreadID(...)
SBBreakpointLocation_SetThreadID(SBBreakpointLocation self, lldb::tid_t sb_thread_id)

SBBreakpointLocation_SetThreadIndex(...)
SBBreakpointLocation_SetThreadIndex(SBBreakpointLocation self, uint32_t index)

SBBreakpointLocation_SetThreadName(...)
SBBreakpointLocation_SetThreadName(SBBreakpointLocation self, char const * thread_name)

SBBreakpointLocation___str__(...)
SBBreakpointLocation___str__(SBBreakpointLocation self) -> PyObject *

SBBreakpointLocation_swigregister(...)

SBBreakpoint_ClearAllBreakpointSites(...)
SBBreakpoint_ClearAllBreakpointSites(SBBreakpoint self)

SBBreakpoint_EventIsBreakpointEvent(...)
SBBreakpoint_EventIsBreakpointEvent(SBEvent event) -> bool

SBBreakpoint_FindLocationByAddress(...)
SBBreakpoint_FindLocationByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> SBBreakpointLocation

SBBreakpoint_FindLocationByID(...)
SBBreakpoint_FindLocationByID(SBBreakpoint self, lldb::break_id_t bp_loc_id) -> SBBreakpointLocation

SBBreakpoint_FindLocationIDByAddress(...)
SBBreakpoint_FindLocationIDByAddress(SBBreakpoint self, lldb::addr_t vm_addr) -> lldb::break_id_t

SBBreakpoint_GetBreakpointEventTypeFromEvent(...)
SBBreakpoint_GetBreakpointEventTypeFromEvent(SBEvent event) -> lldb::BreakpointEventType

SBBreakpoint_GetBreakpointFromEvent(...)
SBBreakpoint_GetBreakpointFromEvent(SBEvent event) -> SBBreakpoint

SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(...)
SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(SBEvent event, uint32_t loc_idx) -> SBBreakpointLocation

SBBreakpoint_GetCondition(...)
SBBreakpoint_GetCondition(SBBreakpoint self) -> char const *

SBBreakpoint_GetDescription(...)
SBBreakpoint_GetDescription(SBBreakpoint self, SBStream description) -> bool

SBBreakpoint_GetHitCount(...)
SBBreakpoint_GetHitCount(SBBreakpoint self) -> uint32_t

SBBreakpoint_GetID(...)
SBBreakpoint_GetID(SBBreakpoint self) -> lldb::break_id_t

SBBreakpoint_GetIgnoreCount(...)
SBBreakpoint_GetIgnoreCount(SBBreakpoint self) -> uint32_t

SBBreakpoint_GetLocationAtIndex(...)
SBBreakpoint_GetLocationAtIndex(SBBreakpoint self, uint32_t index) -> SBBreakpointLocation

SBBreakpoint_GetNumBreakpointLocationsFromEvent(...)
SBBreakpoint_GetNumBreakpointLocationsFromEvent(SBEvent event_sp) -> uint32_t

SBBreakpoint_GetNumLocations(...)
SBBreakpoint_GetNumLocations(SBBreakpoint self) -> size_t

SBBreakpoint_GetNumResolvedLocations(...)
SBBreakpoint_GetNumResolvedLocations(SBBreakpoint self) -> size_t

SBBreakpoint_GetQueueName(...)
SBBreakpoint_GetQueueName(SBBreakpoint self) -> char const *

SBBreakpoint_GetThreadID(...)
SBBreakpoint_GetThreadID(SBBreakpoint self) -> lldb::tid_t

SBBreakpoint_GetThreadIndex(...)
SBBreakpoint_GetThreadIndex(SBBreakpoint self) -> uint32_t

SBBreakpoint_GetThreadName(...)
SBBreakpoint_GetThreadName(SBBreakpoint self) -> char const *

SBBreakpoint_IsEnabled(...)
SBBreakpoint_IsEnabled(SBBreakpoint self) -> bool

SBBreakpoint_IsInternal(...)
SBBreakpoint_IsInternal(SBBreakpoint self) -> bool

SBBreakpoint_IsOneShot(...)
SBBreakpoint_IsOneShot(SBBreakpoint self) -> bool

SBBreakpoint_IsValid(...)
SBBreakpoint_IsValid(SBBreakpoint self) -> bool

SBBreakpoint_SetCallback(...)
SBBreakpoint_SetCallback(SBBreakpoint self, lldb::SBBreakpoint::BreakpointHitCallback callback, void * baton)

SBBreakpoint_SetCondition(...)
SBBreakpoint_SetCondition(SBBreakpoint self, char const * condition)

SBBreakpoint_SetEnabled(...)
SBBreakpoint_SetEnabled(SBBreakpoint self, bool enable)

SBBreakpoint_SetIgnoreCount(...)
SBBreakpoint_SetIgnoreCount(SBBreakpoint self, uint32_t count)

SBBreakpoint_SetOneShot(...)
SBBreakpoint_SetOneShot(SBBreakpoint self, bool one_shot)

SBBreakpoint_SetQueueName(...)
SBBreakpoint_SetQueueName(SBBreakpoint self, char const * queue_name)

SBBreakpoint_SetThreadID(...)
SBBreakpoint_SetThreadID(SBBreakpoint self, lldb::tid_t sb_thread_id)

SBBreakpoint_SetThreadIndex(...)
SBBreakpoint_SetThreadIndex(SBBreakpoint self, uint32_t index)

SBBreakpoint_SetThreadName(...)
SBBreakpoint_SetThreadName(SBBreakpoint self, char const * thread_name)

SBBreakpoint___eq__(...)
SBBreakpoint___eq__(SBBreakpoint self, SBBreakpoint rhs) -> bool

SBBreakpoint___ne__(...)
SBBreakpoint___ne__(SBBreakpoint self, SBBreakpoint rhs) -> bool

SBBreakpoint___str__(...)
SBBreakpoint___str__(SBBreakpoint self) -> PyObject *

SBBreakpoint_swigregister(...)

SBBroadcaster_AddInitialEventsToListener(...)
SBBroadcaster_AddInitialEventsToListener(SBBroadcaster self, SBListener listener, uint32_t requested_events)

SBBroadcaster_AddListener(...)
SBBroadcaster_AddListener(SBBroadcaster self, SBListener listener, uint32_t event_mask) -> uint32_t

SBBroadcaster_BroadcastEvent(...)
BroadcastEvent(SBEvent event, bool unique=False) SBBroadcaster_BroadcastEvent(SBBroadcaster self, SBEvent event)

SBBroadcaster_BroadcastEventByType(...)
BroadcastEventByType(uint32_t event_type, bool unique=False) SBBroadcaster_BroadcastEventByType(SBBroadcaster self, uint32_t event_type)

SBBroadcaster_Clear(...)
SBBroadcaster_Clear(SBBroadcaster self)

SBBroadcaster_EventTypeHasListeners(...)
SBBroadcaster_EventTypeHasListeners(SBBroadcaster self, uint32_t event_type) -> bool

SBBroadcaster_GetName(...)
SBBroadcaster_GetName(SBBroadcaster self) -> char const *

SBBroadcaster_IsValid(...)
SBBroadcaster_IsValid(SBBroadcaster self) -> bool

SBBroadcaster_RemoveListener(...)
RemoveListener(SBListener listener, uint32_t event_mask=4294967295U) -> bool SBBroadcaster_RemoveListener(SBBroadcaster self, SBListener listener) -> bool

SBBroadcaster___eq__(...)
SBBroadcaster___eq__(SBBroadcaster self, SBBroadcaster rhs) -> bool

SBBroadcaster___ne__(...)
SBBroadcaster___ne__(SBBroadcaster self, SBBroadcaster rhs) -> bool

SBBroadcaster_swigregister(...)

SBCommandInterpreter_AliasExists(...)
SBCommandInterpreter_AliasExists(SBCommandInterpreter self, char const * cmd) -> bool

SBCommandInterpreter_CommandExists(...)
SBCommandInterpreter_CommandExists(SBCommandInterpreter self, char const * cmd) -> bool

SBCommandInterpreter_GetArgumentDescriptionAsCString(...)
SBCommandInterpreter_GetArgumentDescriptionAsCString(lldb::CommandArgumentType const arg_type) -> char const *

SBCommandInterpreter_GetArgumentTypeAsCString(...)
SBCommandInterpreter_GetArgumentTypeAsCString(lldb::CommandArgumentType const arg_type) -> char const *

SBCommandInterpreter_GetBroadcaster(...)
SBCommandInterpreter_GetBroadcaster(SBCommandInterpreter self) -> SBBroadcaster

char const *

SBCommandInterpreter_GetBroadcasterClass()

SBCommandInterpreter_GetDebugger(...)
SBCommandInterpreter_GetDebugger(SBCommandInterpreter self) -> SBDebugger

SBCommandInterpreter_GetProcess(...)
SBCommandInterpreter_GetProcess(SBCommandInterpreter self) -> SBProcess

SBCommandInterpreter_HandleCommand(...)
HandleCommand(char const * command_line, SBCommandReturnObject result, bool add_to_history=False) -> lldb::ReturnStatus SBCommandInterpreter_HandleCommand(SBCommandInterpreter self, char const * command_line, SBCommandReturnObject result) -> lldb::ReturnStatus

SBCommandInterpreter_HandleCompletion(...)
SBCommandInterpreter_HandleCompletion(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, ...

SBCommandInterpreter_HasAliasOptions(...)
SBCommandInterpreter_HasAliasOptions(SBCommandInterpreter self) -> bool

SBCommandInterpreter_HasAliases(...)
SBCommandInterpreter_HasAliases(SBCommandInterpreter self) -> bool

SBCommandInterpreter_HasCommands(...)
SBCommandInterpreter_HasCommands(SBCommandInterpreter self) -> bool

SBCommandInterpreter_IsValid(...)
SBCommandInterpreter_IsValid(SBCommandInterpreter self) -> bool

SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(...)
SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(SBCommandInterpreter self, SBCommandReturnObject result)

SBCommandInterpreter_SourceInitFileInHomeDirectory(...)
SBCommandInterpreter_SourceInitFileInHomeDirectory(SBCommandInterpreter self, SBCommandReturnObject result)

SBCommandInterpreter_swigregister(...)

SBCommandReturnObject_AppendMessage(...)
SBCommandReturnObject_AppendMessage(SBCommandReturnObject self, char const * message)

SBCommandReturnObject_AppendWarning(...)
SBCommandReturnObject_AppendWarning(SBCommandReturnObject self, char const * message)

SBCommandReturnObject_Clear(...)
SBCommandReturnObject_Clear(SBCommandReturnObject self)

SBCommandReturnObject_GetDescription(...)
SBCommandReturnObject_GetDescription(SBCommandReturnObject self, SBStream description) -> bool

char const

SBCommandReturnObject_GetError()
SBCommandReturnObject_GetError(SBCommandReturnObject self, bool if_no_immediate) -> char const *

SBCommandReturnObject_GetErrorSize(...)
SBCommandReturnObject_GetErrorSize(SBCommandReturnObject self) -> size_t

char const

SBCommandReturnObject_GetOutput()
SBCommandReturnObject_GetOutput(SBCommandReturnObject self, bool only_if_no_immediate) -> char const *

SBCommandReturnObject_GetOutputSize(...)
SBCommandReturnObject_GetOutputSize(SBCommandReturnObject self) -> size_t

SBCommandReturnObject_GetStatus(...)
SBCommandReturnObject_GetStatus(SBCommandReturnObject self) -> lldb::ReturnStatus

SBCommandReturnObject_HasResult(...)
SBCommandReturnObject_HasResult(SBCommandReturnObject self) -> bool

SBCommandReturnObject_IsValid(...)
SBCommandReturnObject_IsValid(SBCommandReturnObject self) -> bool

SBCommandReturnObject_Print(...)
SBCommandReturnObject_Print(SBCommandReturnObject self, char const * str)

SBCommandReturnObject_PutCString(...)
SBCommandReturnObject_PutCString(SBCommandReturnObject self, char const * string)

SBCommandReturnObject_PutError(...)
SBCommandReturnObject_PutError(SBCommandReturnObject self, FILE * fh) -> size_t

SBCommandReturnObject_PutOutput(...)
SBCommandReturnObject_PutOutput(SBCommandReturnObject self, FILE * fh) -> size_t

SBCommandReturnObject_SetError(...)
SetError(SBError error, char const * fallback_error_cstr=None) SetError(SBError error) SBCommandReturnObject_SetError(SBCommandReturnObject self, char const * error_cstr)

SBCommandReturnObject_SetImmediateErrorFile(...)
SBCommandReturnObject_SetImmediateErrorFile(SBCommandReturnObject self, FILE * fh)

SBCommandReturnObject_SetImmediateOutputFile(...)
SBCommandReturnObject_SetImmediateOutputFile(SBCommandReturnObject self, FILE * fh)

SBCommandReturnObject_SetStatus(...)
SBCommandReturnObject_SetStatus(SBCommandReturnObject self, lldb::ReturnStatus status)

SBCommandReturnObject_Succeeded(...)
SBCommandReturnObject_Succeeded(SBCommandReturnObject self) -> bool

SBCommandReturnObject___str__(...)
SBCommandReturnObject___str__(SBCommandReturnObject self) -> PyObject *

SBCommandReturnObject_flush(...)
SBCommandReturnObject_flush(SBCommandReturnObject self)

SBCommandReturnObject_swigregister(...)

SBCommandReturnObject_write(...)
SBCommandReturnObject_write(SBCommandReturnObject self, char const * str)

SBCommunication_AdoptFileDesriptor(...)
SBCommunication_AdoptFileDesriptor(SBCommunication self, int fd, bool owns_fd) -> lldb::ConnectionStatus

SBCommunication_Connect(...)
SBCommunication_Connect(SBCommunication self, char const * url) -> lldb::ConnectionStatus

SBCommunication_Disconnect(...)
SBCommunication_Disconnect(SBCommunication self) -> lldb::ConnectionStatus

SBCommunication_GetBroadcaster(...)
SBCommunication_GetBroadcaster(SBCommunication self) -> SBBroadcaster

char const *

SBCommunication_GetBroadcasterClass()

SBCommunication_GetCloseOnEOF(...)
SBCommunication_GetCloseOnEOF(SBCommunication self) -> bool

SBCommunication_IsConnected(...)
SBCommunication_IsConnected(SBCommunication self) -> bool

SBCommunication_IsValid(...)
SBCommunication_IsValid(SBCommunication self) -> bool

SBCommunication_Read(...)
SBCommunication_Read(SBCommunication self, void * dst, size_t dst_len, uint32_t timeout_usec, lldb::ConnectionStatus & status) -> size_t

SBCommunication_ReadThreadIsRunning(...)
SBCommunication_ReadThreadIsRunning(SBCommunication self) -> bool

SBCommunication_ReadThreadStart(...)
SBCommunication_ReadThreadStart(SBCommunication self) -> bool

SBCommunication_ReadThreadStop(...)
SBCommunication_ReadThreadStop(SBCommunication self) -> bool

SBCommunication_SetCloseOnEOF(...)
SBCommunication_SetCloseOnEOF(SBCommunication self, bool b)

SBCommunication_SetReadThreadBytesReceivedCallback(...)
SBCommunication_SetReadThreadBytesReceivedCallback(SBCommunication self, lldb::SBCommunication::ReadThreadBytesReceived callback, void * callback_baton) -> bool

SBCommunication_Write(...)
SBCommunication_Write(SBCommunication self, void const * src, size_t src_len, lldb::ConnectionStatus & status) -> size_t

SBCommunication_swigregister(...)

SBCompileUnit_FindLineEntryIndex(...)
FindLineEntryIndex(uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec) -> uint32_t...

SBCompileUnit_FindSupportFileIndex(...)
SBCompileUnit_FindSupportFileIndex(SBCompileUnit self, uint32_t start_idx, SBFileSpec sb_file, bool full) -> uint32_t

SBCompileUnit_GetDescription(...)
SBCompileUnit_GetDescription(SBCompileUnit self, SBStream description) -> bool

SBCompileUnit_GetFileSpec(...)
SBCompileUnit_GetFileSpec(SBCompileUnit self) -> SBFileSpec

SBCompileUnit_GetLineEntryAtIndex(...)
SBCompileUnit_GetLineEntryAtIndex(SBCompileUnit self, uint32_t idx) -> SBLineEntry

SBCompileUnit_GetNumLineEntries(...)
SBCompileUnit_GetNumLineEntries(SBCompileUnit self) -> uint32_t

SBCompileUnit_GetNumSupportFiles(...)
SBCompileUnit_GetNumSupportFiles(SBCompileUnit self) -> uint32_t

SBCompileUnit_GetSupportFileAtIndex(...)
SBCompileUnit_GetSupportFileAtIndex(SBCompileUnit self, uint32_t idx) -> SBFileSpec

SBCompileUnit_GetTypes(...)
GetTypes(uint32_t type_mask=eTypeClassAny) -> SBTypeList SBCompileUnit_GetTypes(SBCompileUnit self) -> SBTypeList

SBCompileUnit_IsValid(...)
SBCompileUnit_IsValid(SBCompileUnit self) -> bool

SBCompileUnit___eq__(...)
SBCompileUnit___eq__(SBCompileUnit self, SBCompileUnit rhs) -> bool

SBCompileUnit___ne__(...)
SBCompileUnit___ne__(SBCompileUnit self, SBCompileUnit rhs) -> bool

SBCompileUnit___str__(...)
SBCompileUnit___str__(SBCompileUnit self) -> PyObject *

SBCompileUnit_swigregister(...)

SBData_Append(...)
SBData_Append(SBData self, SBData rhs) -> bool

SBData_Clear(...)
SBData_Clear(SBData self)

SBData_CreateDataFromCString(...)
SBData_CreateDataFromCString(lldb::ByteOrder endian, uint32_t addr_byte_size, char const * data) -> SBData

SBData_CreateDataFromDoubleArray(...)
SBData_CreateDataFromDoubleArray(lldb::ByteOrder endian, uint32_t addr_byte_size, double * array) -> SBData

SBData_CreateDataFromSInt32Array(...)
SBData_CreateDataFromSInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int32_t * array) -> SBData

SBData_CreateDataFromSInt64Array(...)
SBData_CreateDataFromSInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, int64_t * array) -> SBData

SBData_CreateDataFromUInt32Array(...)
SBData_CreateDataFromUInt32Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint32_t * array) -> SBData

SBData_CreateDataFromUInt64Array(...)
SBData_CreateDataFromUInt64Array(lldb::ByteOrder endian, uint32_t addr_byte_size, uint64_t * array) -> SBData

SBData_GetAddress(...)
SBData_GetAddress(SBData self, SBError error, lldb::offset_t offset) -> lldb::addr_t

SBData_GetAddressByteSize(...)
SBData_GetAddressByteSize(SBData self) -> uint8_t

SBData_GetByteOrder(...)
SBData_GetByteOrder(SBData self) -> lldb::ByteOrder

SBData_GetByteSize(...)
SBData_GetByteSize(SBData self) -> size_t

SBData_GetDescription(...)
SBData_GetDescription(SBData self, SBStream description, lldb::addr_t base_addr) -> bool

SBData_GetDouble(...)
SBData_GetDouble(SBData self, SBError error, lldb::offset_t offset) -> double

SBData_GetFloat(...)
SBData_GetFloat(SBData self, SBError error, lldb::offset_t offset) -> float

SBData_GetLongDouble(...)
SBData_GetLongDouble(SBData self, SBError error, lldb::offset_t offset) -> long double

SBData_GetSignedInt16(...)
SBData_GetSignedInt16(SBData self, SBError error, lldb::offset_t offset) -> int16_t

SBData_GetSignedInt32(...)
SBData_GetSignedInt32(SBData self, SBError error, lldb::offset_t offset) -> int32_t

SBData_GetSignedInt64(...)
SBData_GetSignedInt64(SBData self, SBError error, lldb::offset_t offset) -> int64_t

SBData_GetSignedInt8(...)
SBData_GetSignedInt8(SBData self, SBError error, lldb::offset_t offset) -> int8_t

SBData_GetString(...)
SBData_GetString(SBData self, SBError error, lldb::offset_t offset) -> char const *

SBData_GetUnsignedInt16(...)
SBData_GetUnsignedInt16(SBData self, SBError error, lldb::offset_t offset) -> uint16_t

SBData_GetUnsignedInt32(...)
SBData_GetUnsignedInt32(SBData self, SBError error, lldb::offset_t offset) -> uint32_t

SBData_GetUnsignedInt64(...)
SBData_GetUnsignedInt64(SBData self, SBError error, lldb::offset_t offset) -> uint64_t

SBData_GetUnsignedInt8(...)
SBData_GetUnsignedInt8(SBData self, SBError error, lldb::offset_t offset) -> uint8_t

SBData_IsValid(...)
SBData_IsValid(SBData self) -> bool

SBData_ReadRawData(...)
SBData_ReadRawData(SBData self, SBError error, lldb::offset_t offset, void * buf) -> size_t

SBData_SetAddressByteSize(...)
SBData_SetAddressByteSize(SBData self, uint8_t addr_byte_size)

SBData_SetByteOrder(...)
SBData_SetByteOrder(SBData self, lldb::ByteOrder endian)

SBData_SetData(...)
SBData_SetData(SBData self, SBError error, void const * buf, lldb::ByteOrder endian, uint8_t addr_size)

SBData_SetDataFromCString(...)
SBData_SetDataFromCString(SBData self, char const * data) -> bool

SBData_SetDataFromDoubleArray(...)
SBData_SetDataFromDoubleArray(SBData self, double * array) -> bool

SBData_SetDataFromSInt32Array(...)
SBData_SetDataFromSInt32Array(SBData self, int32_t * array) -> bool

SBData_SetDataFromSInt64Array(...)
SBData_SetDataFromSInt64Array(SBData self, int64_t * array) -> bool

SBData_SetDataFromUInt32Array(...)
SBData_SetDataFromUInt32Array(SBData self, uint32_t * array) -> bool

SBData_SetDataFromUInt64Array(...)
SBData_SetDataFromUInt64Array(SBData self, uint64_t * array) -> bool

SBData___str__(...)
SBData___str__(SBData self) -> PyObject *

SBData_swigregister(...)

SBDebugger_Clear(...)
SBDebugger_Clear(SBDebugger self)

SBDebugger

SBDebugger_Create()
Create(bool source_init_files) -> SBDebugger SBDebugger_Create(bool source_init_files, lldb::LogOutputCallback log_callback) -> SBDebugger

SBDebugger_CreateCategory(...)
SBDebugger_CreateCategory(SBDebugger self, char const * category_name) -> SBTypeCategory

SBDebugger_CreateTarget(...)
CreateTarget(char const * filename, char const * target_triple, char const * platform_name, bool add_dependent_modules, ...

SBDebugger_CreateTargetWithFileAndArch(...)
SBDebugger_CreateTargetWithFileAndArch(SBDebugger self, char const * filename, char const * archname) -> SBTarget

SBDebugger_CreateTargetWithFileAndTargetTriple(...)
SBDebugger_CreateTargetWithFileAndTargetTriple(SBDebugger self, char const * filename, char const * target_triple) -> SBTarget

SBDebugger_DeleteCategory(...)
SBDebugger_DeleteCategory(SBDebugger self, char const * category_name) -> bool

SBDebugger_DeleteTarget(...)
SBDebugger_DeleteTarget(SBDebugger self, SBTarget target) -> bool

SBDebugger_Destroy(...)
SBDebugger_Destroy(SBDebugger debugger)

SBDebugger_DispatchInput(...)
SBDebugger_DispatchInput(SBDebugger self, void const * data)

SBDebugger_DispatchInputEndOfFile(...)
SBDebugger_DispatchInputEndOfFile(SBDebugger self)

SBDebugger_DispatchInputInterrupt(...)
SBDebugger_DispatchInputInterrupt(SBDebugger self)

SBDebugger_EnableLog(...)
SBDebugger_EnableLog(SBDebugger self, char const * channel, char const ** types) -> bool

SBDebugger_FindDebuggerWithID(...)
SBDebugger_FindDebuggerWithID(int id) -> SBDebugger

SBDebugger_FindTargetWithFileAndArch(...)
SBDebugger_FindTargetWithFileAndArch(SBDebugger self, char const * filename, char const * arch) -> SBTarget

SBDebugger_FindTargetWithProcessID(...)
SBDebugger_FindTargetWithProcessID(SBDebugger self, lldb::pid_t pid) -> SBTarget

SBDebugger_GetAsync(...)
SBDebugger_GetAsync(SBDebugger self) -> bool

SBDebugger_GetCategory(...)
SBDebugger_GetCategory(SBDebugger self, char const * category_name) -> SBTypeCategory

SBDebugger_GetCategoryAtIndex(...)
SBDebugger_GetCategoryAtIndex(SBDebugger self, uint32_t arg2) -> SBTypeCategory

SBDebugger_GetCloseInputOnEOF(...)
SBDebugger_GetCloseInputOnEOF(SBDebugger self) -> bool

SBDebugger_GetCommandInterpreter(...)
SBDebugger_GetCommandInterpreter(SBDebugger self) -> SBCommandInterpreter

SBDebugger_GetDefaultArchitecture(...)
SBDebugger_GetDefaultArchitecture(char * arch_name, size_t arch_name_len) -> bool

SBDebugger_GetDefaultCategory(...)
SBDebugger_GetDefaultCategory(SBDebugger self) -> SBTypeCategory

SBDebugger_GetDescription(...)
SBDebugger_GetDescription(SBDebugger self, SBStream description) -> bool

SBDebugger_GetErrorFileHandle(...)
SBDebugger_GetErrorFileHandle(SBDebugger self) -> FILE *

SBDebugger_GetFilterForType(...)
SBDebugger_GetFilterForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeFilter

SBDebugger_GetFormatForType(...)
SBDebugger_GetFormatForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeFormat

SBDebugger_GetID(...)
SBDebugger_GetID(SBDebugger self) -> lldb::user_id_t

SBDebugger_GetIndexOfTarget(...)
SBDebugger_GetIndexOfTarget(SBDebugger self, SBTarget target) -> uint32_t

SBDebugger_GetInputFileHandle(...)
SBDebugger_GetInputFileHandle(SBDebugger self) -> FILE *

SBDebugger_GetInstanceName(...)
SBDebugger_GetInstanceName(SBDebugger self) -> char const *

SBDebugger_GetInternalVariableValue(...)
SBDebugger_GetInternalVariableValue(char const * var_name, char const * debugger_instance_name) -> SBStringList

SBDebugger_GetListener(...)
SBDebugger_GetListener(SBDebugger self) -> SBListener

SBDebugger_GetNumCategories(...)
SBDebugger_GetNumCategories(SBDebugger self) -> uint32_t

SBDebugger_GetNumTargets(...)
SBDebugger_GetNumTargets(SBDebugger self) -> uint32_t

SBDebugger_GetOutputFileHandle(...)
SBDebugger_GetOutputFileHandle(SBDebugger self) -> FILE *

SBDebugger_GetPrompt(...)
SBDebugger_GetPrompt(SBDebugger self) -> char const *

SBDebugger_GetScriptLanguage(...)
SBDebugger_GetScriptLanguage(SBDebugger self) -> lldb::ScriptLanguage

SBDebugger_GetScriptingLanguage(...)
SBDebugger_GetScriptingLanguage(SBDebugger self, char const * script_language_name) -> lldb::ScriptLanguage

SBDebugger_GetSelectedTarget(...)
SBDebugger_GetSelectedTarget(SBDebugger self) -> SBTarget

SBDebugger_GetSourceManager(...)
SBDebugger_GetSourceManager(SBDebugger self) -> SBSourceManager

SBDebugger_GetSummaryForType(...)
SBDebugger_GetSummaryForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeSummary

SBDebugger_GetSyntheticForType(...)
SBDebugger_GetSyntheticForType(SBDebugger self, SBTypeNameSpecifier arg2) -> SBTypeSynthetic

SBDebugger_GetTargetAtIndex(...)
SBDebugger_GetTargetAtIndex(SBDebugger self, uint32_t idx) -> SBTarget

SBDebugger_GetTerminalWidth(...)
SBDebugger_GetTerminalWidth(SBDebugger self) -> uint32_t

SBDebugger_GetUseExternalEditor(...)
SBDebugger_GetUseExternalEditor(SBDebugger self) -> bool

char const *

SBDebugger_GetVersionString()

SBDebugger_HandleCommand(...)
SBDebugger_HandleCommand(SBDebugger self, char const * command)

SBDebugger_HandleProcessEvent(...)
SBDebugger_HandleProcessEvent(SBDebugger self, SBProcess process, SBEvent event, FILE * out, FILE * err)

SBDebugger_Initialize()

SBDebugger_InputReaderIsTopReader(...)
SBDebugger_InputReaderIsTopReader(SBDebugger self, SBInputReader reader) -> bool

SBDebugger_IsValid(...)
SBDebugger_IsValid(SBDebugger self) -> bool

SBDebugger_MemoryPressureDetected()

SBDebugger_NotifyTopInputReader(...)
SBDebugger_NotifyTopInputReader(SBDebugger self, lldb::InputReaderAction notification)

SBDebugger_PushInputReader(...)
SBDebugger_PushInputReader(SBDebugger self, SBInputReader reader)

SBDebugger_SetAsync(...)
SBDebugger_SetAsync(SBDebugger self, bool b)

SBDebugger_SetCloseInputOnEOF(...)
SBDebugger_SetCloseInputOnEOF(SBDebugger self, bool b)

SBDebugger_SetCurrentPlatform(...)
SBDebugger_SetCurrentPlatform(SBDebugger self, char const * platform_name) -> SBError

SBDebugger_SetCurrentPlatformSDKRoot(...)
SBDebugger_SetCurrentPlatformSDKRoot(SBDebugger self, char const * sysroot) -> bool

SBDebugger_SetDefaultArchitecture(...)
SBDebugger_SetDefaultArchitecture(char const * arch_name) -> bool

SBDebugger_SetErrorFileHandle(...)
SBDebugger_SetErrorFileHandle(SBDebugger self, FILE * f, bool transfer_ownership)

SBDebugger_SetInputFileHandle(...)
SBDebugger_SetInputFileHandle(SBDebugger self, FILE * f, bool transfer_ownership)

SBDebugger_SetInternalVariable(...)
SBDebugger_SetInternalVariable(char const * var_name, char const * value, char const * debugger_instance_name) -> SBError

SBDebugger_SetLoggingCallback(...)
SBDebugger_SetLoggingCallback(SBDebugger self, lldb::LogOutputCallback log_callback)

SBDebugger_SetOutputFileHandle(...)
SBDebugger_SetOutputFileHandle(SBDebugger self, FILE * f, bool transfer_ownership)

SBDebugger_SetPrompt(...)
SBDebugger_SetPrompt(SBDebugger self, char const * prompt)

SBDebugger_SetScriptLanguage(...)
SBDebugger_SetScriptLanguage(SBDebugger self, lldb::ScriptLanguage script_lang)

SBDebugger_SetSelectedTarget(...)
SBDebugger_SetSelectedTarget(SBDebugger self, SBTarget target)

SBDebugger_SetTerminalWidth(...)
SBDebugger_SetTerminalWidth(SBDebugger self, uint32_t term_width)

SBDebugger_SetUseExternalEditor(...)
SBDebugger_SetUseExternalEditor(SBDebugger self, bool input) -> bool

SBDebugger_SkipLLDBInitFiles(...)
SBDebugger_SkipLLDBInitFiles(SBDebugger self, bool b)

SBDebugger_StateAsCString(...)
SBDebugger_StateAsCString(lldb::StateType state) -> char const *

SBDebugger_StateIsRunningState(...)
SBDebugger_StateIsRunningState(lldb::StateType state) -> bool

SBDebugger_StateIsStoppedState(...)
SBDebugger_StateIsStoppedState(lldb::StateType state) -> bool

SBDebugger_Terminate()

SBDebugger___str__(...)
SBDebugger___str__(SBDebugger self) -> PyObject *

SBDebugger_swigregister(...)

SBDeclaration_GetColumn(...)
SBDeclaration_GetColumn(SBDeclaration self) -> uint32_t

SBDeclaration_GetDescription(...)
SBDeclaration_GetDescription(SBDeclaration self, SBStream description) -> bool

SBDeclaration_GetFileSpec(...)
SBDeclaration_GetFileSpec(SBDeclaration self) -> SBFileSpec

SBDeclaration_GetLine(...)
SBDeclaration_GetLine(SBDeclaration self) -> uint32_t

SBDeclaration_IsValid(...)
SBDeclaration_IsValid(SBDeclaration self) -> bool

SBDeclaration_SetColumn(...)
SBDeclaration_SetColumn(SBDeclaration self, uint32_t column)

SBDeclaration_SetFileSpec(...)
SBDeclaration_SetFileSpec(SBDeclaration self, SBFileSpec filespec)

SBDeclaration_SetLine(...)
SBDeclaration_SetLine(SBDeclaration self, uint32_t line)

SBDeclaration___eq__(...)
SBDeclaration___eq__(SBDeclaration self, SBDeclaration rhs) -> bool

SBDeclaration___ne__(...)
SBDeclaration___ne__(SBDeclaration self, SBDeclaration rhs) -> bool

SBDeclaration___str__(...)
SBDeclaration___str__(SBDeclaration self) -> PyObject *

SBDeclaration_swigregister(...)

SBError_Clear(...)
SBError_Clear(SBError self)

SBError_Fail(...)
SBError_Fail(SBError self) -> bool

SBError_GetCString(...)
SBError_GetCString(SBError self) -> char const *

SBError_GetDescription(...)
SBError_GetDescription(SBError self, SBStream description) -> bool

SBError_GetError(...)
SBError_GetError(SBError self) -> uint32_t

SBError_GetType(...)
SBError_GetType(SBError self) -> lldb::ErrorType

SBError_IsValid(...)
SBError_IsValid(SBError self) -> bool

SBError_SetError(...)
SBError_SetError(SBError self, uint32_t err, lldb::ErrorType type)

SBError_SetErrorString(...)
SBError_SetErrorString(SBError self, char const * err_str)

SBError_SetErrorStringWithFormat(...)
SBError_SetErrorStringWithFormat(SBError self, char const * format) -> int

SBError_SetErrorToErrno(...)
SBError_SetErrorToErrno(SBError self)

SBError_SetErrorToGenericError(...)
SBError_SetErrorToGenericError(SBError self)

SBError_Success(...)
SBError_Success(SBError self) -> bool

SBError___str__(...)
SBError___str__(SBError self) -> PyObject *

SBError_swigregister(...)

SBEvent_BroadcasterMatchesRef(...)
SBEvent_BroadcasterMatchesRef(SBEvent self, SBBroadcaster broadcaster) -> bool

SBEvent_Clear(...)
SBEvent_Clear(SBEvent self)

SBEvent_GetBroadcaster(...)
SBEvent_GetBroadcaster(SBEvent self) -> SBBroadcaster

SBEvent_GetBroadcasterClass(...)
SBEvent_GetBroadcasterClass(SBEvent self) -> char const *

SBEvent_GetCStringFromEvent(...)
SBEvent_GetCStringFromEvent(SBEvent event) -> char const *

SBEvent_GetDataFlavor(...)
SBEvent_GetDataFlavor(SBEvent self) -> char const *

SBEvent_GetDescription(...)
SBEvent_GetDescription(SBEvent self, SBStream description) -> bool

SBEvent_GetType(...)
SBEvent_GetType(SBEvent self) -> uint32_t

SBEvent_IsValid(...)
SBEvent_IsValid(SBEvent self) -> bool

SBEvent_swigregister(...)

SBExpressionOptions_GetCoerceResultToId(...)
SBExpressionOptions_GetCoerceResultToId(SBExpressionOptions self) -> bool

SBExpressionOptions_GetFetchDynamicValue(...)
SBExpressionOptions_GetFetchDynamicValue(SBExpressionOptions self) -> lldb::DynamicValueType

SBExpressionOptions_GetIgnoreBreakpoints(...)
SBExpressionOptions_GetIgnoreBreakpoints(SBExpressionOptions self) -> bool

SBExpressionOptions_GetTimeoutInMicroSeconds(...)
SBExpressionOptions_GetTimeoutInMicroSeconds(SBExpressionOptions self) -> uint32_t

SBExpressionOptions_GetTryAllThreads(...)
SBExpressionOptions_GetTryAllThreads(SBExpressionOptions self) -> bool

SBExpressionOptions_GetUnwindOnError(...)
SBExpressionOptions_GetUnwindOnError(SBExpressionOptions self) -> bool

SBExpressionOptions_SetCoerceResultToId(...)
SetCoerceResultToId(bool coerce=True) SBExpressionOptions_SetCoerceResultToId(SBExpressionOptions self)

SBExpressionOptions_SetFetchDynamicValue(...)
SetFetchDynamicValue(lldb::DynamicValueType dynamic=eDynamicCanRunTarget) SBExpressionOptions_SetFetchDynamicValue(SBExpressionOptions self)

SBExpressionOptions_SetIgnoreBreakpoints(...)
SetIgnoreBreakpoints(bool ignore=True) SBExpressionOptions_SetIgnoreBreakpoints(SBExpressionOptions self)

SBExpressionOptions_SetTimeoutInMicroSeconds(...)
SetTimeoutInMicroSeconds(uint32_t timeout=0) SBExpressionOptions_SetTimeoutInMicroSeconds(SBExpressionOptions self)

SBExpressionOptions_SetTryAllThreads(...)
SetTryAllThreads(bool run_others=True) SBExpressionOptions_SetTryAllThreads(SBExpressionOptions self)

SBExpressionOptions_SetUnwindOnError(...)
SetUnwindOnError(bool unwind=True) SBExpressionOptions_SetUnwindOnError(SBExpressionOptions self)

SBExpressionOptions_swigregister(...)

SBFileSpecList_Append(...)
SBFileSpecList_Append(SBFileSpecList self, SBFileSpec sb_file)

SBFileSpecList_AppendIfUnique(...)
SBFileSpecList_AppendIfUnique(SBFileSpecList self, SBFileSpec sb_file) -> bool

SBFileSpecList_Clear(...)
SBFileSpecList_Clear(SBFileSpecList self)

SBFileSpecList_FindFileIndex(...)
SBFileSpecList_FindFileIndex(SBFileSpecList self, uint32_t idx, SBFileSpec sb_file, bool full) -> uint32_t

SBFileSpecList_GetDescription(...)
SBFileSpecList_GetDescription(SBFileSpecList self, SBStream description) -> bool

SBFileSpecList_GetFileSpecAtIndex(...)
SBFileSpecList_GetFileSpecAtIndex(SBFileSpecList self, uint32_t idx) -> SBFileSpec

SBFileSpecList_GetSize(...)
SBFileSpecList_GetSize(SBFileSpecList self) -> uint32_t

SBFileSpecList_swigregister(...)

SBFileSpec_Exists(...)
SBFileSpec_Exists(SBFileSpec self) -> bool

SBFileSpec_GetDescription(...)
SBFileSpec_GetDescription(SBFileSpec self, SBStream description) -> bool

SBFileSpec_GetDirectory(...)
SBFileSpec_GetDirectory(SBFileSpec self) -> char const *

SBFileSpec_GetFilename(...)
SBFileSpec_GetFilename(SBFileSpec self) -> char const *

SBFileSpec_GetPath(...)
SBFileSpec_GetPath(SBFileSpec self, char * dst_path, size_t dst_len) -> uint32_t

SBFileSpec_IsValid(...)
SBFileSpec_IsValid(SBFileSpec self) -> bool

SBFileSpec_ResolveExecutableLocation(...)
SBFileSpec_ResolveExecutableLocation(SBFileSpec self) -> bool

SBFileSpec_ResolvePath(...)
SBFileSpec_ResolvePath(char const * src_path, char * dst_path, size_t dst_len) -> int

SBFileSpec___str__(...)
SBFileSpec___str__(SBFileSpec self) -> PyObject *

SBFileSpec_swigregister(...)

SBFrame_Clear(...)
SBFrame_Clear(SBFrame self)

SBFrame_Disassemble(...)
SBFrame_Disassemble(SBFrame self) -> char const *

SBFrame_EvaluateExpression(...)
EvaluateExpression(char const * expr) -> SBValue EvaluateExpression(char const * expr, lldb::DynamicValueType use_dynamic) -> SBValue EvaluateExpression(char const * expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error) -> SBValue SBFrame_EvaluateExpression(SBFrame self, char const * expr, SBExpressionOptions options) -> SBValue

SBFrame_FindValue(...)
FindValue(char const * name, lldb::ValueType value_type) -> SBValue SBFrame_FindValue(SBFrame self, char const * name, lldb::ValueType value_type, lldb::DynamicValueType use_dynamic) -> SBValue

SBFrame_FindVariable(...)
FindVariable(char const * var_name) -> SBValue SBFrame_FindVariable(SBFrame self, char const * var_name, lldb::DynamicValueType use_dynamic) -> SBValue

SBFrame_GetBlock(...)
SBFrame_GetBlock(SBFrame self) -> SBBlock

SBFrame_GetCompileUnit(...)
SBFrame_GetCompileUnit(SBFrame self) -> SBCompileUnit

SBFrame_GetDescription(...)
SBFrame_GetDescription(SBFrame self, SBStream description) -> bool

SBFrame_GetFP(...)
SBFrame_GetFP(SBFrame self) -> lldb::addr_t

SBFrame_GetFrameBlock(...)
SBFrame_GetFrameBlock(SBFrame self) -> SBBlock

SBFrame_GetFrameID(...)
SBFrame_GetFrameID(SBFrame self) -> uint32_t

SBFrame_GetFunction(...)
SBFrame_GetFunction(SBFrame self) -> SBFunction

SBFrame_GetFunctionName(...)
SBFrame_GetFunctionName(SBFrame self) -> char const *

SBFrame_GetLineEntry(...)
SBFrame_GetLineEntry(SBFrame self) -> SBLineEntry

SBFrame_GetModule(...)
SBFrame_GetModule(SBFrame self) -> SBModule

SBFrame_GetPC(...)
SBFrame_GetPC(SBFrame self) -> lldb::addr_t

SBFrame_GetPCAddress(...)
SBFrame_GetPCAddress(SBFrame self) -> SBAddress

SBFrame_GetRegisters(...)
SBFrame_GetRegisters(SBFrame self) -> SBValueList

SBFrame_GetSP(...)
SBFrame_GetSP(SBFrame self) -> lldb::addr_t

SBFrame_GetSymbol(...)
SBFrame_GetSymbol(SBFrame self) -> SBSymbol

SBFrame_GetSymbolContext(...)
SBFrame_GetSymbolContext(SBFrame self, uint32_t resolve_scope) -> SBSymbolContext

SBFrame_GetThread(...)
SBFrame_GetThread(SBFrame self) -> SBThread

SBFrame_GetValueForVariablePath(...)
GetValueForVariablePath(char const * var_path) -> SBValue SBFrame_GetValueForVariablePath(SBFrame self, char const * var_path, lldb::DynamicValueType use_dynamic) -> SBValue

SBFrame_GetVariables(...)
GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only) -> SBValueList SBFrame_GetVariables(SBFrame self, bool arguments, bool locals, bool statics, bool in_scope_only, lldb::DynamicValueType use_dynamic) -> SBValueList

SBFrame_IsEqual(...)
SBFrame_IsEqual(SBFrame self, SBFrame rhs) -> bool

SBFrame_IsInlined(...)
SBFrame_IsInlined(SBFrame self) -> bool

SBFrame_IsValid(...)
SBFrame_IsValid(SBFrame self) -> bool

SBFrame_SetPC(...)
SBFrame_SetPC(SBFrame self, lldb::addr_t new_pc) -> bool

SBFrame___str__(...)
SBFrame___str__(SBFrame self) -> PyObject *

SBFrame_swigregister(...)

SBFunction_GetBlock(...)
SBFunction_GetBlock(SBFunction self) -> SBBlock

SBFunction_GetDescription(...)
SBFunction_GetDescription(SBFunction self, SBStream description) -> bool

SBFunction_GetEndAddress(...)
SBFunction_GetEndAddress(SBFunction self) -> SBAddress

SBFunction_GetInstructions(...)
GetInstructions(SBTarget target) -> SBInstructionList SBFunction_GetInstructions(SBFunction self, SBTarget target, char const * flavor) -> SBInstructionList

SBFunction_GetMangledName(...)
SBFunction_GetMangledName(SBFunction self) -> char const *

SBFunction_GetName(...)
SBFunction_GetName(SBFunction self) -> char const *

SBFunction_GetPrologueByteSize(...)
SBFunction_GetPrologueByteSize(SBFunction self) -> uint32_t

SBFunction_GetStartAddress(...)
SBFunction_GetStartAddress(SBFunction self) -> SBAddress

SBFunction_GetType(...)
SBFunction_GetType(SBFunction self) -> SBType

SBFunction_IsValid(...)
SBFunction_IsValid(SBFunction self) -> bool

SBFunction___eq__(...)
SBFunction___eq__(SBFunction self, SBFunction rhs) -> bool

SBFunction___ne__(...)
SBFunction___ne__(SBFunction self, SBFunction rhs) -> bool

SBFunction___str__(...)
SBFunction___str__(SBFunction self) -> PyObject *

SBFunction_swigregister(...)

SBFileSpec

SBHostOS_GetProgramFileSpec()

SBHostOS_ThreadCancel(...)
SBHostOS_ThreadCancel(lldb::thread_t thread, SBError err) -> bool

SBHostOS_ThreadCreate(...)
SBHostOS_ThreadCreate(char const * name, void *(*)(void *) thread_function, void * thread_arg, SBError err) -> lldb::thread_t

SBHostOS_ThreadCreated(...)
SBHostOS_ThreadCreated(char const * name)

SBHostOS_ThreadDetach(...)
SBHostOS_ThreadDetach(lldb::thread_t thread, SBError err) -> bool

SBHostOS_ThreadJoin(...)
SBHostOS_ThreadJoin(lldb::thread_t thread, void ** result, SBError err) -> bool

SBHostOS_swigregister(...)

SBInputReader_GetGranularity(...)
SBInputReader_GetGranularity(SBInputReader self) -> lldb::InputReaderGranularity

SBInputReader_Initialize(...)
SBInputReader_Initialize(SBInputReader self, SBDebugger debugger, lldb::SBInputReader::Callback callback, ...

SBInputReader_IsActive(...)
SBInputReader_IsActive(SBInputReader self) -> bool

SBInputReader_IsDone(...)
SBInputReader_IsDone(SBInputReader self) -> bool

SBInputReader_IsValid(...)
SBInputReader_IsValid(SBInputReader self) -> bool

SBInputReader_SetIsDone(...)
SBInputReader_SetIsDone(SBInputReader self, bool value)

SBInputReader_swigregister(...)

SBInstructionList_AppendInstruction(...)
SBInstructionList_AppendInstruction(SBInstructionList self, SBInstruction inst)

SBInstructionList_Clear(...)
SBInstructionList_Clear(SBInstructionList self)

SBInstructionList_DumpEmulationForAllInstructions(...)
SBInstructionList_DumpEmulationForAllInstructions(SBInstructionList self, char const * triple) -> bool

SBInstructionList_GetDescription(...)
SBInstructionList_GetDescription(SBInstructionList self, SBStream description) -> bool

SBInstructionList_GetInstructionAtIndex(...)
SBInstructionList_GetInstructionAtIndex(SBInstructionList self, uint32_t idx) -> SBInstruction

SBInstructionList_GetSize(...)
SBInstructionList_GetSize(SBInstructionList self) -> size_t

SBInstructionList_IsValid(...)
SBInstructionList_IsValid(SBInstructionList self) -> bool

SBInstructionList_Print(...)
SBInstructionList_Print(SBInstructionList self, FILE * out)

SBInstructionList___str__(...)
SBInstructionList___str__(SBInstructionList self) -> PyObject *

SBInstructionList_swigregister(...)

SBInstruction_DoesBranch(...)
SBInstruction_DoesBranch(SBInstruction self) -> bool

SBInstruction_DumpEmulation(...)
SBInstruction_DumpEmulation(SBInstruction self, char const * triple) -> bool

SBInstruction_EmulateWithFrame(...)
SBInstruction_EmulateWithFrame(SBInstruction self, SBFrame frame, uint32_t evaluate_options) -> bool

SBInstruction_GetAddress(...)
SBInstruction_GetAddress(SBInstruction self) -> SBAddress

SBInstruction_GetAddressClass(...)
SBInstruction_GetAddressClass(SBInstruction self) -> lldb::AddressClass

SBInstruction_GetByteSize(...)
SBInstruction_GetByteSize(SBInstruction self) -> size_t

SBInstruction_GetComment(...)
SBInstruction_GetComment(SBInstruction self, SBTarget target) -> char const *

SBInstruction_GetData(...)
SBInstruction_GetData(SBInstruction self, SBTarget target) -> SBData

SBInstruction_GetDescription(...)
SBInstruction_GetDescription(SBInstruction self, SBStream description) -> bool

SBInstruction_GetMnemonic(...)
SBInstruction_GetMnemonic(SBInstruction self, SBTarget target) -> char const *

SBInstruction_GetOperands(...)
SBInstruction_GetOperands(SBInstruction self, SBTarget target) -> char const *

SBInstruction_IsValid(...)
SBInstruction_IsValid(SBInstruction self) -> bool

SBInstruction_Print(...)
SBInstruction_Print(SBInstruction self, FILE * out)

SBInstruction_TestEmulation(...)
SBInstruction_TestEmulation(SBInstruction self, SBStream output_stream, char const * test_file) -> bool

SBInstruction___str__(...)
SBInstruction___str__(SBInstruction self) -> PyObject *

SBInstruction_swigregister(...)

SBLaunchInfo_AddCloseFileAction(...)
SBLaunchInfo_AddCloseFileAction(SBLaunchInfo self, int fd) -> bool

SBLaunchInfo_AddDuplicateFileAction(...)
SBLaunchInfo_AddDuplicateFileAction(SBLaunchInfo self, int fd, int dup_fd) -> bool

SBLaunchInfo_AddOpenFileAction(...)
SBLaunchInfo_AddOpenFileAction(SBLaunchInfo self, int fd, char const * path, bool read, bool write) -> bool

SBLaunchInfo_AddSuppressFileAction(...)
SBLaunchInfo_AddSuppressFileAction(SBLaunchInfo self, int fd, bool read, bool write) -> bool

SBLaunchInfo_Clear(...)
SBLaunchInfo_Clear(SBLaunchInfo self)

SBLaunchInfo_GetArgumentAtIndex(...)
SBLaunchInfo_GetArgumentAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *

SBLaunchInfo_GetEnvironmentEntryAtIndex(...)
SBLaunchInfo_GetEnvironmentEntryAtIndex(SBLaunchInfo self, uint32_t idx) -> char const *

SBLaunchInfo_GetGroupID(...)
SBLaunchInfo_GetGroupID(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetLaunchFlags(...)
SBLaunchInfo_GetLaunchFlags(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetNumArguments(...)
SBLaunchInfo_GetNumArguments(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetNumEnvironmentEntries(...)
SBLaunchInfo_GetNumEnvironmentEntries(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetProcessPluginName(...)
SBLaunchInfo_GetProcessPluginName(SBLaunchInfo self) -> char const *

SBLaunchInfo_GetResumeCount(...)
SBLaunchInfo_GetResumeCount(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetShell(...)
SBLaunchInfo_GetShell(SBLaunchInfo self) -> char const *

SBLaunchInfo_GetUserID(...)
SBLaunchInfo_GetUserID(SBLaunchInfo self) -> uint32_t

SBLaunchInfo_GetWorkingDirectory(...)
SBLaunchInfo_GetWorkingDirectory(SBLaunchInfo self) -> char const *

SBLaunchInfo_GroupIDIsValid(...)
SBLaunchInfo_GroupIDIsValid(SBLaunchInfo self) -> bool

SBLaunchInfo_SetArguments(...)
SBLaunchInfo_SetArguments(SBLaunchInfo self, char const ** argv, bool append)

SBLaunchInfo_SetEnvironmentEntries(...)
SBLaunchInfo_SetEnvironmentEntries(SBLaunchInfo self, char const ** envp, bool append)

SBLaunchInfo_SetGroupID(...)
SBLaunchInfo_SetGroupID(SBLaunchInfo self, uint32_t gid)

SBLaunchInfo_SetLaunchFlags(...)
SBLaunchInfo_SetLaunchFlags(SBLaunchInfo self, uint32_t flags)

SBLaunchInfo_SetProcessPluginName(...)
SBLaunchInfo_SetProcessPluginName(SBLaunchInfo self, char const * plugin_name)

SBLaunchInfo_SetResumeCount(...)
SBLaunchInfo_SetResumeCount(SBLaunchInfo self, uint32_t c)

SBLaunchInfo_SetShell(...)
SBLaunchInfo_SetShell(SBLaunchInfo self, char const * path)

SBLaunchInfo_SetUserID(...)
SBLaunchInfo_SetUserID(SBLaunchInfo self, uint32_t uid)

SBLaunchInfo_SetWorkingDirectory(...)
SBLaunchInfo_SetWorkingDirectory(SBLaunchInfo self, char const * working_dir)

SBLaunchInfo_UserIDIsValid(...)
SBLaunchInfo_UserIDIsValid(SBLaunchInfo self) -> bool

SBLaunchInfo_swigregister(...)

SBLineEntry_GetColumn(...)
SBLineEntry_GetColumn(SBLineEntry self) -> uint32_t

SBLineEntry_GetDescription(...)
SBLineEntry_GetDescription(SBLineEntry self, SBStream description) -> bool

SBLineEntry_GetEndAddress(...)
SBLineEntry_GetEndAddress(SBLineEntry self) -> SBAddress

SBLineEntry_GetFileSpec(...)
SBLineEntry_GetFileSpec(SBLineEntry self) -> SBFileSpec

SBLineEntry_GetLine(...)
SBLineEntry_GetLine(SBLineEntry self) -> uint32_t

SBLineEntry_GetStartAddress(...)
SBLineEntry_GetStartAddress(SBLineEntry self) -> SBAddress

SBLineEntry_IsValid(...)
SBLineEntry_IsValid(SBLineEntry self) -> bool

SBLineEntry_SetColumn(...)
SBLineEntry_SetColumn(SBLineEntry self, uint32_t column)

SBLineEntry_SetFileSpec(...)
SBLineEntry_SetFileSpec(SBLineEntry self, SBFileSpec filespec)

SBLineEntry_SetLine(...)
SBLineEntry_SetLine(SBLineEntry self, uint32_t line)

SBLineEntry___eq__(...)
SBLineEntry___eq__(SBLineEntry self, SBLineEntry rhs) -> bool

SBLineEntry___ne__(...)
SBLineEntry___ne__(SBLineEntry self, SBLineEntry rhs) -> bool

SBLineEntry___str__(...)
SBLineEntry___str__(SBLineEntry self) -> PyObject *

SBLineEntry_swigregister(...)

SBListener_AddEvent(...)
SBListener_AddEvent(SBListener self, SBEvent event)

SBListener_Clear(...)
SBListener_Clear(SBListener self)

SBListener_GetNextEvent(...)
SBListener_GetNextEvent(SBListener self, SBEvent sb_event) -> bool

SBListener_GetNextEventForBroadcaster(...)
SBListener_GetNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool

SBListener_GetNextEventForBroadcasterWithType(...)
SBListener_GetNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool

SBListener_HandleBroadcastEvent(...)
SBListener_HandleBroadcastEvent(SBListener self, SBEvent event) -> bool

SBListener_IsValid(...)
SBListener_IsValid(SBListener self) -> bool

SBListener_PeekAtNextEvent(...)
SBListener_PeekAtNextEvent(SBListener self, SBEvent sb_event) -> bool

SBListener_PeekAtNextEventForBroadcaster(...)
SBListener_PeekAtNextEventForBroadcaster(SBListener self, SBBroadcaster broadcaster, SBEvent sb_event) -> bool

SBListener_PeekAtNextEventForBroadcasterWithType(...)
SBListener_PeekAtNextEventForBroadcasterWithType(SBListener self, SBBroadcaster broadcaster, uint32_t event_type_mask, SBEvent sb_event) -> bool

SBListener_StartListeningForEventClass(...)
SBListener_StartListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> uint32_t

SBListener_StartListeningForEvents(...)
SBListener_StartListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> uint32_t

SBListener_StopListeningForEventClass(...)
SBListener_StopListeningForEventClass(SBListener self, SBDebugger debugger, char const * broadcaster_class, uint32_t event_mask) -> uint32_t

SBListener_StopListeningForEvents(...)
SBListener_StopListeningForEvents(SBListener self, SBBroadcaster broadcaster, uint32_t event_mask) -> bool

SBListener_WaitForEvent(...)
SBListener_WaitForEvent(SBListener self, uint32_t num_seconds, SBEvent event) -> bool

SBListener_WaitForEventForBroadcaster(...)
SBListener_WaitForEventForBroadcaster(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, SBEvent sb_event) -> bool

SBListener_WaitForEventForBroadcasterWithType(...)
SBListener_WaitForEventForBroadcasterWithType(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, uint32_t event_type_mask, ...

SBListener_swigregister(...)

SBModuleSpecList_Append(...)
Append(SBModuleSpec spec) SBModuleSpecList_Append(SBModuleSpecList self, SBModuleSpecList spec_list)

SBModuleSpecList_FindFirstMatchingSpec(...)
SBModuleSpecList_FindFirstMatchingSpec(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpec

SBModuleSpecList_FindMatchingSpecs(...)
SBModuleSpecList_FindMatchingSpecs(SBModuleSpecList self, SBModuleSpec match_spec) -> SBModuleSpecList

SBModuleSpecList_GetDescription(...)
SBModuleSpecList_GetDescription(SBModuleSpecList self, SBStream description) -> bool

SBModuleSpecList_GetModuleSpecifications(...)
SBModuleSpecList_GetModuleSpecifications(char const * path) -> SBModuleSpecList

SBModuleSpecList_GetSize(...)
SBModuleSpecList_GetSize(SBModuleSpecList self) -> size_t

SBModuleSpecList_GetSpecAtIndex(...)
SBModuleSpecList_GetSpecAtIndex(SBModuleSpecList self, size_t i) -> SBModuleSpec

SBModuleSpecList___str__(...)
SBModuleSpecList___str__(SBModuleSpecList self) -> PyObject *

SBModuleSpecList_swigregister(...)

SBModuleSpec_Clear(...)
SBModuleSpec_Clear(SBModuleSpec self)

SBModuleSpec_GetDescription(...)
SBModuleSpec_GetDescription(SBModuleSpec self, SBStream description) -> bool

SBModuleSpec_GetFileSpec(...)
SBModuleSpec_GetFileSpec(SBModuleSpec self) -> SBFileSpec

SBModuleSpec_GetObjectName(...)
SBModuleSpec_GetObjectName(SBModuleSpec self) -> char const *

SBModuleSpec_GetPlatformFileSpec(...)
SBModuleSpec_GetPlatformFileSpec(SBModuleSpec self) -> SBFileSpec

SBModuleSpec_GetSymbolFileSpec(...)
SBModuleSpec_GetSymbolFileSpec(SBModuleSpec self) -> SBFileSpec

SBModuleSpec_GetTriple(...)
SBModuleSpec_GetTriple(SBModuleSpec self) -> char const *

SBModuleSpec_GetUUIDBytes(...)
SBModuleSpec_GetUUIDBytes(SBModuleSpec self) -> uint8_t const *

SBModuleSpec_GetUUIDLength(...)
SBModuleSpec_GetUUIDLength(SBModuleSpec self) -> size_t

SBModuleSpec_IsValid(...)
SBModuleSpec_IsValid(SBModuleSpec self) -> bool

SBModuleSpec_SetFileSpec(...)
SBModuleSpec_SetFileSpec(SBModuleSpec self, SBFileSpec fspec)

SBModuleSpec_SetObjectName(...)
SBModuleSpec_SetObjectName(SBModuleSpec self, char const * name)

SBModuleSpec_SetPlatformFileSpec(...)
SBModuleSpec_SetPlatformFileSpec(SBModuleSpec self, SBFileSpec fspec)

SBModuleSpec_SetSymbolFileSpec(...)
SBModuleSpec_SetSymbolFileSpec(SBModuleSpec self, SBFileSpec fspec)

SBModuleSpec_SetTriple(...)
SBModuleSpec_SetTriple(SBModuleSpec self, char const * triple)

SBModuleSpec_SetUUIDBytes(...)
SBModuleSpec_SetUUIDBytes(SBModuleSpec self, uint8_t const * uuid, size_t uuid_len) -> bool

SBModuleSpec___str__(...)
SBModuleSpec___str__(SBModuleSpec self) -> PyObject *

SBModuleSpec_swigregister(...)

SBModule_Clear(...)
SBModule_Clear(SBModule self)

SBModule_FindFirstGlobalVariable(...)
SBModule_FindFirstGlobalVariable(SBModule self, SBTarget target, char const * name) -> SBValue

SBModule_FindFirstType(...)
SBModule_FindFirstType(SBModule self, char const * name) -> SBType

SBModule_FindFunctions(...)
FindFunctions(char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList SBModule_FindFunctions(SBModule self, char const * name) -> SBSymbolContextList

SBModule_FindGlobalVariables(...)
SBModule_FindGlobalVariables(SBModule self, SBTarget target, char const * name, uint32_t max_matches) -> SBValueList

SBModule_FindSection(...)
SBModule_FindSection(SBModule self, char const * sect_name) -> SBSection

SBModule_FindSymbol(...)
FindSymbol(char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbol SBModule_FindSymbol(SBModule self, char const * name) -> SBSymbol

SBModule_FindSymbols(...)
FindSymbols(char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList SBModule_FindSymbols(SBModule self, char const * name) -> SBSymbolContextList

SBModule_FindTypes(...)
SBModule_FindTypes(SBModule self, char const * type) -> SBTypeList

SBModule_GetAddressByteSize(...)
SBModule_GetAddressByteSize(SBModule self) -> uint32_t

SBModule_GetBasicType(...)
SBModule_GetBasicType(SBModule self, lldb::BasicType type) -> SBType

SBModule_GetByteOrder(...)
SBModule_GetByteOrder(SBModule self) -> lldb::ByteOrder

SBModule_GetCompileUnitAtIndex(...)
SBModule_GetCompileUnitAtIndex(SBModule self, uint32_t arg2) -> SBCompileUnit

SBModule_GetDescription(...)
SBModule_GetDescription(SBModule self, SBStream description) -> bool

SBModule_GetFileSpec(...)
SBModule_GetFileSpec(SBModule self) -> SBFileSpec

SBModule_GetNumCompileUnits(...)
SBModule_GetNumCompileUnits(SBModule self) -> uint32_t

SBModule_GetNumSections(...)
SBModule_GetNumSections(SBModule self) -> size_t

SBModule_GetNumSymbols(...)
SBModule_GetNumSymbols(SBModule self) -> size_t

SBModule_GetPlatformFileSpec(...)
SBModule_GetPlatformFileSpec(SBModule self) -> SBFileSpec

SBModule_GetSectionAtIndex(...)
SBModule_GetSectionAtIndex(SBModule self, size_t idx) -> SBSection

SBModule_GetSymbolAtIndex(...)
SBModule_GetSymbolAtIndex(SBModule self, size_t idx) -> SBSymbol

SBModule_GetTriple(...)
SBModule_GetTriple(SBModule self) -> char const *

SBModule_GetTypes(...)
GetTypes(uint32_t type_mask=eTypeClassAny) -> SBTypeList SBModule_GetTypes(SBModule self) -> SBTypeList

SBModule_GetUUIDString(...)
SBModule_GetUUIDString(SBModule self) -> char const *

SBModule_GetVersion(...)
SBModule_GetVersion(SBModule self) -> uint32_t

SBModule_IsValid(...)
SBModule_IsValid(SBModule self) -> bool

SBModule_ResolveFileAddress(...)
SBModule_ResolveFileAddress(SBModule self, lldb::addr_t vm_addr) -> SBAddress

SBModule_ResolveSymbolContextForAddress(...)
SBModule_ResolveSymbolContextForAddress(SBModule self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext

SBModule_SetPlatformFileSpec(...)
SBModule_SetPlatformFileSpec(SBModule self, SBFileSpec platform_file) -> bool

SBModule___eq__(...)
SBModule___eq__(SBModule self, SBModule rhs) -> bool

SBModule___ne__(...)
SBModule___ne__(SBModule self, SBModule rhs) -> bool

SBModule___str__(...)
SBModule___str__(SBModule self) -> PyObject *

SBModule_swigregister(...)

SBProcess_AppendEventStateReport(...)
SBProcess_AppendEventStateReport(SBProcess self, SBEvent event, SBCommandReturnObject result)

SBProcess_Clear(...)
SBProcess_Clear(SBProcess self)

SBProcess_Continue(...)
SBProcess_Continue(SBProcess self) -> SBError

SBProcess_CreateOSPluginThread(...)
Lazily create a thread on demand through the current OperatingSystem plug-in, if the current OperatingSystem plug-in supports it.

SBProcess_Destroy(...)
SBProcess_Destroy(SBProcess self) -> SBError

SBProcess_Detach(...)
SBProcess_Detach(SBProcess self) -> SBError

SBProcess_EventIsProcessEvent(...)
SBProcess_EventIsProcessEvent(SBEvent event) -> bool

SBProcess_GetAddressByteSize(...)
SBProcess_GetAddressByteSize(SBProcess self) -> uint32_t

SBProcess_GetAsyncProfileData(...)
SBProcess_GetAsyncProfileData(SBProcess self, char * dst) -> size_t

SBProcess_GetBroadcaster(...)
SBProcess_GetBroadcaster(SBProcess self) -> SBBroadcaster

char const *

SBProcess_GetBroadcasterClassName()

SBProcess_GetByteOrder(...)
SBProcess_GetByteOrder(SBProcess self) -> lldb::ByteOrder

SBProcess_GetDescription(...)
SBProcess_GetDescription(SBProcess self, SBStream description) -> bool

SBProcess_GetExitDescription(...)
SBProcess_GetExitDescription(SBProcess self) -> char const *

SBProcess_GetExitStatus(...)
SBProcess_GetExitStatus(SBProcess self) -> int

SBProcess_GetNumRestartedReasonsFromEvent(...)
SBProcess_GetNumRestartedReasonsFromEvent(SBEvent event) -> size_t

SBProcess_GetNumSupportedHardwareWatchpoints(...)
SBProcess_GetNumSupportedHardwareWatchpoints(SBProcess self, SBError error) -> uint32_t

SBProcess_GetNumThreads(...)
SBProcess_GetNumThreads(SBProcess self) -> uint32_t

SBProcess_GetPluginName(...)
SBProcess_GetPluginName(SBProcess self) -> char const *

SBProcess_GetProcessFromEvent(...)
SBProcess_GetProcessFromEvent(SBEvent event) -> SBProcess

SBProcess_GetProcessID(...)
Returns the process ID of the process.

SBProcess_GetRestartedFromEvent(...)
SBProcess_GetRestartedFromEvent(SBEvent event) -> bool

SBProcess_GetRestartedReasonAtIndexFromEvent(...)
SBProcess_GetRestartedReasonAtIndexFromEvent(SBEvent event, size_t idx) -> char const *

SBProcess_GetSTDERR(...)
Reads data from the current process's stderr stream.

SBProcess_GetSTDOUT(...)
Reads data from the current process's stdout stream.

SBProcess_GetSelectedThread(...)
Returns the currently selected thread.

SBProcess_GetShortPluginName(...)
SBProcess_GetShortPluginName(SBProcess self) -> char const *

SBProcess_GetState(...)
SBProcess_GetState(SBProcess self) -> lldb::StateType

SBProcess_GetStateFromEvent(...)
SBProcess_GetStateFromEvent(SBEvent event) -> lldb::StateType

SBProcess_GetStopID(...)
GetStopID(bool include_expression_stops=False) -> uint32_t SBProcess_GetStopID(SBProcess self) -> uint32_t

SBProcess_GetTarget(...)
SBProcess_GetTarget(SBProcess self) -> SBTarget

SBProcess_GetThreadAtIndex(...)
Returns the INDEX'th thread from the list of current threads.

SBProcess_GetThreadByID(...)
Returns the thread with the given thread ID.

SBProcess_GetThreadByIndexID(...)
Returns the thread with the given thread IndexID.

SBProcess_GetUniqueID(...)
Returns an integer ID that is guaranteed to be unique across all process instances.

SBProcess_IsValid(...)
SBProcess_IsValid(SBProcess self) -> bool

SBProcess_Kill(...)
SBProcess_Kill(SBProcess self) -> SBError

SBProcess_LoadImage(...)
SBProcess_LoadImage(SBProcess self, SBFileSpec image_spec, SBError error) -> uint32_t

SBProcess_PutSTDIN(...)
Writes data into the current process's stdin.

SBProcess_ReadCStringFromMemory(...)
Reads a NULL terminated C string from the current process's address space.

SBProcess_ReadMemory(...)
Reads memory from the current process's address space and removes any traps that may have been inserted into the memory.

SBProcess_ReadPointerFromMemory(...)
Reads a pointer from memory from an address and returns the value.

SBProcess_ReadUnsignedFromMemory(...)
Reads an unsigned integer from memory given a byte size and an address.

SBProcess_RemoteAttachToProcessWithID(...)
SBProcess_RemoteAttachToProcessWithID(SBProcess self, lldb::pid_t pid, SBError error) -> bool

SBProcess_RemoteLaunch(...)
SBProcess_RemoteLaunch(SBProcess self, char const ** argv, char const ** envp, char const * stdin_path, char const * stdout_path, char const * stderr_path, char const * working_directory, uint32_t launch_flags, bool stop_at_entry, SBError error) -> bool

SBProcess_ReportEventState(...)
SBProcess_ReportEventState(SBProcess self, SBEvent event, FILE * out)

SBProcess_SendAsyncInterrupt(...)
SBProcess_SendAsyncInterrupt(SBProcess self)

SBProcess_SetSelectedThread(...)
SBProcess_SetSelectedThread(SBProcess self, SBThread thread) -> bool

SBProcess_SetSelectedThreadByID(...)
SBProcess_SetSelectedThreadByID(SBProcess self, lldb::tid_t tid) -> bool

SBProcess_SetSelectedThreadByIndexID(...)
SBProcess_SetSelectedThreadByIndexID(SBProcess self, uint32_t index_id) -> bool

SBProcess_Signal(...)
SBProcess_Signal(SBProcess self, int signal) -> SBError

SBProcess_Stop(...)
SBProcess_Stop(SBProcess self) -> SBError

SBProcess_UnloadImage(...)
SBProcess_UnloadImage(SBProcess self, uint32_t image_token) -> SBError

SBProcess_WriteMemory(...)
Writes memory to the current process's address space and maintains any traps that might be present due to software breakpoints.

SBProcess___str__(...)
SBProcess___str__(SBProcess self) -> PyObject *

SBProcess_swigregister(...)

SBSection_FindSubSection(...)
SBSection_FindSubSection(SBSection self, char const * sect_name) -> SBSection

SBSection_GetByteSize(...)
SBSection_GetByteSize(SBSection self) -> lldb::addr_t

SBSection_GetDescription(...)
SBSection_GetDescription(SBSection self, SBStream description) -> bool

SBSection_GetFileAddress(...)
SBSection_GetFileAddress(SBSection self) -> lldb::addr_t

SBSection_GetFileByteSize(...)
SBSection_GetFileByteSize(SBSection self) -> uint64_t

SBSection_GetFileOffset(...)
SBSection_GetFileOffset(SBSection self) -> uint64_t

SBSection_GetLoadAddress(...)
SBSection_GetLoadAddress(SBSection self, SBTarget target) -> lldb::addr_t

SBSection_GetName(...)
SBSection_GetName(SBSection self) -> char const *

SBSection_GetNumSubSections(...)
SBSection_GetNumSubSections(SBSection self) -> size_t

SBSection_GetParent(...)
SBSection_GetParent(SBSection self) -> SBSection

SBData

SBSection_GetSectionData()
SBSection_GetSectionData(SBSection self, uint64_t offset, uint64_t size) -> SBData

SBSection_GetSectionType(...)
SBSection_GetSectionType(SBSection self) -> lldb::SectionType

SBSection_GetSubSectionAtIndex(...)
SBSection_GetSubSectionAtIndex(SBSection self, size_t idx) -> SBSection

SBSection_IsValid(...)
SBSection_IsValid(SBSection self) -> bool

SBSection___eq__(...)
SBSection___eq__(SBSection self, SBSection rhs) -> bool

SBSection___ne__(...)
SBSection___ne__(SBSection self, SBSection rhs) -> bool

SBSection___str__(...)
SBSection___str__(SBSection self) -> PyObject *

SBSection_swigregister(...)

SBSourceManager_DisplaySourceLinesWithLineNumbers(...)
SBSourceManager_DisplaySourceLinesWithLineNumbers(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t context_before, uint32_t context_after, ...

SBSourceManager_swigregister(...)

SBStream_Clear(...)
SBStream_Clear(SBStream self)

SBStream_GetData(...)
SBStream_GetData(SBStream self) -> char const *

SBStream_GetSize(...)
SBStream_GetSize(SBStream self) -> size_t

SBStream_IsValid(...)
SBStream_IsValid(SBStream self) -> bool

SBStream_Print(...)
SBStream_Print(SBStream self, char const * str)

SBStream_RedirectToFile(...)
SBStream_RedirectToFile(SBStream self, char const * path, bool append)

SBStream_RedirectToFileDescriptor(...)
SBStream_RedirectToFileDescriptor(SBStream self, int fd, bool transfer_fh_ownership)

SBStream_RedirectToFileHandle(...)
SBStream_RedirectToFileHandle(SBStream self, FILE * fh, bool transfer_fh_ownership)

SBStream_flush(...)
SBStream_flush(SBStream self)

SBStream_swigregister(...)

SBStream_write(...)
SBStream_write(SBStream self, char const * str)

SBStringList_AppendList(...)
AppendList(char const ** strv, int strc) SBStringList_AppendList(SBStringList self, SBStringList strings)

SBStringList_AppendString(...)
SBStringList_AppendString(SBStringList self, char const * str)

SBStringList_Clear(...)
SBStringList_Clear(SBStringList self)

SBStringList_GetSize(...)
SBStringList_GetSize(SBStringList self) -> uint32_t

SBStringList_GetStringAtIndex(...)
SBStringList_GetStringAtIndex(SBStringList self, size_t idx) -> char const *

SBStringList_IsValid(...)
SBStringList_IsValid(SBStringList self) -> bool

SBStringList_swigregister(...)

SBSymbolContextList_Append(...)
Append(SBSymbolContext sc) SBSymbolContextList_Append(SBSymbolContextList self, SBSymbolContextList sc_list)

SBSymbolContextList_Clear(...)
SBSymbolContextList_Clear(SBSymbolContextList self)

SBSymbolContextList_GetContextAtIndex(...)
SBSymbolContextList_GetContextAtIndex(SBSymbolContextList self, uint32_t idx) -> SBSymbolContext

SBSymbolContextList_GetDescription(...)
SBSymbolContextList_GetDescription(SBSymbolContextList self, SBStream description) -> bool

SBSymbolContextList_GetSize(...)
SBSymbolContextList_GetSize(SBSymbolContextList self) -> uint32_t

SBSymbolContextList_IsValid(...)
SBSymbolContextList_IsValid(SBSymbolContextList self) -> bool

SBSymbolContextList___str__(...)
SBSymbolContextList___str__(SBSymbolContextList self) -> PyObject *

SBSymbolContextList_swigregister(...)

SBSymbolContext_GetBlock(...)
SBSymbolContext_GetBlock(SBSymbolContext self) -> SBBlock

SBSymbolContext_GetCompileUnit(...)
SBSymbolContext_GetCompileUnit(SBSymbolContext self) -> SBCompileUnit

SBSymbolContext_GetDescription(...)
SBSymbolContext_GetDescription(SBSymbolContext self, SBStream description) -> bool

SBSymbolContext_GetFunction(...)
SBSymbolContext_GetFunction(SBSymbolContext self) -> SBFunction

SBSymbolContext_GetLineEntry(...)
SBSymbolContext_GetLineEntry(SBSymbolContext self) -> SBLineEntry

SBSymbolContext_GetModule(...)
SBSymbolContext_GetModule(SBSymbolContext self) -> SBModule

SBSymbolContext_GetParentOfInlinedScope(...)
SBSymbolContext_GetParentOfInlinedScope(SBSymbolContext self, SBAddress curr_frame_pc, SBAddress parent_frame_addr) -> SBSymbolContext

SBSymbolContext_GetSymbol(...)
SBSymbolContext_GetSymbol(SBSymbolContext self) -> SBSymbol

SBSymbolContext_IsValid(...)
SBSymbolContext_IsValid(SBSymbolContext self) -> bool

SBSymbolContext_SetBlock(...)
SBSymbolContext_SetBlock(SBSymbolContext self, SBBlock block)

SBSymbolContext_SetCompileUnit(...)
SBSymbolContext_SetCompileUnit(SBSymbolContext self, SBCompileUnit compile_unit)

SBSymbolContext_SetFunction(...)
SBSymbolContext_SetFunction(SBSymbolContext self, SBFunction function)

SBSymbolContext_SetLineEntry(...)
SBSymbolContext_SetLineEntry(SBSymbolContext self, SBLineEntry line_entry)

SBSymbolContext_SetModule(...)
SBSymbolContext_SetModule(SBSymbolContext self, SBModule module)

SBSymbolContext_SetSymbol(...)
SBSymbolContext_SetSymbol(SBSymbolContext self, SBSymbol symbol)

SBSymbolContext___str__(...)
SBSymbolContext___str__(SBSymbolContext self) -> PyObject *

SBSymbolContext_swigregister(...)

SBSymbol_GetDescription(...)
SBSymbol_GetDescription(SBSymbol self, SBStream description) -> bool

SBSymbol_GetEndAddress(...)
SBSymbol_GetEndAddress(SBSymbol self) -> SBAddress

SBSymbol_GetInstructions(...)
GetInstructions(SBTarget target) -> SBInstructionList SBSymbol_GetInstructions(SBSymbol self, SBTarget target, char const * flavor_string) -> SBInstructionList

SBSymbol_GetMangledName(...)
SBSymbol_GetMangledName(SBSymbol self) -> char const *

SBSymbol_GetName(...)
SBSymbol_GetName(SBSymbol self) -> char const *

SBSymbol_GetPrologueByteSize(...)
SBSymbol_GetPrologueByteSize(SBSymbol self) -> uint32_t

SBSymbol_GetStartAddress(...)
SBSymbol_GetStartAddress(SBSymbol self) -> SBAddress

SBSymbol_GetType(...)
SBSymbol_GetType(SBSymbol self) -> lldb::SymbolType

SBSymbol_IsExternal(...)
SBSymbol_IsExternal(SBSymbol self) -> bool

SBSymbol_IsSynthetic(...)
SBSymbol_IsSynthetic(SBSymbol self) -> bool

SBSymbol_IsValid(...)
SBSymbol_IsValid(SBSymbol self) -> bool

SBSymbol___eq__(...)
SBSymbol___eq__(SBSymbol self, SBSymbol rhs) -> bool

SBSymbol___ne__(...)
SBSymbol___ne__(SBSymbol self, SBSymbol rhs) -> bool

SBSymbol___str__(...)
SBSymbol___str__(SBSymbol self) -> PyObject *

SBSymbol_swigregister(...)

SBTarget_AddModule(...)
AddModule(SBModule module) -> bool AddModule(char const * path, char const * triple, char const * uuid) -> SBModule AddModule(char const * path, char const * triple, char const * uuid_cstr, char const * symfile) -> SBModule SBTarget_AddModule(SBTarget self, SBModuleSpec module_spec) -> SBModule

SBTarget_Attach(...)
SBTarget_Attach(SBTarget self, SBAttachInfo attach_info, SBError error) -> SBProcess

SBTarget_AttachToProcessWithID(...)
SBTarget_AttachToProcessWithID(SBTarget self, SBListener listener, lldb::pid_t pid, SBError error) -> SBProcess

SBTarget_AttachToProcessWithName(...)
SBTarget_AttachToProcessWithName(SBTarget self, SBListener listener, char const * name, bool wait_for, SBError error) -> SBProcess

SBTarget_BreakpointCreateByAddress(...)
SBTarget_BreakpointCreateByAddress(SBTarget self, lldb::addr_t address) -> SBBreakpoint

SBTarget_BreakpointCreateByLocation(...)
BreakpointCreateByLocation(char const * file, uint32_t line) -> SBBreakpoint SBTarget_BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line) -> SBBreakpoint

SBTarget_BreakpointCreateByName(...)
BreakpointCreateByName(char const * symbol_name, char const * module_name=None) -> SBBreakpoint...

SBTarget_BreakpointCreateByNames(...)
SBTarget_BreakpointCreateByNames(SBTarget self, char const *[] symbol_name, uint32_t num_names, uint32_t name_type_mask, ...

SBTarget_BreakpointCreateByRegex(...)
BreakpointCreateByRegex(char const * symbol_name_regex, char const * module_name=None) -> SBBreakpoint SBTarget_BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex) -> SBBreakpoint

SBTarget_BreakpointCreateBySourceRegex(...)
BreakpointCreateBySourceRegex(char const * source_regex, SBFileSpec source_file, char const * module_name=None) -> SBBreakpoint SBTarget_BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpec source_file) -> SBBreakpoint

SBTarget_BreakpointCreateForException(...)
SBTarget_BreakpointCreateForException(SBTarget self, lldb::LanguageType language, bool catch_bp, bool throw_bp) -> SBBreakpoint

SBTarget_BreakpointDelete(...)
SBTarget_BreakpointDelete(SBTarget self, lldb::break_id_t break_id) -> bool

SBTarget_Clear(...)
SBTarget_Clear(SBTarget self)

SBTarget_ClearModuleLoadAddress(...)
SBTarget_ClearModuleLoadAddress(SBTarget self, SBModule module) -> SBError

SBTarget_ClearSectionLoadAddress(...)
SBTarget_ClearSectionLoadAddress(SBTarget self, SBSection section) -> SBError

SBTarget_ConnectRemote(...)
SBTarget_ConnectRemote(SBTarget self, SBListener listener, char const * url, char const * plugin_name, SBError error) -> SBProcess

SBTarget_DeleteAllBreakpoints(...)
SBTarget_DeleteAllBreakpoints(SBTarget self) -> bool

SBTarget_DeleteAllWatchpoints(...)
SBTarget_DeleteAllWatchpoints(SBTarget self) -> bool

SBTarget_DeleteWatchpoint(...)
SBTarget_DeleteWatchpoint(SBTarget self, lldb::watch_id_t watch_id) -> bool

SBTarget_DisableAllBreakpoints(...)
SBTarget_DisableAllBreakpoints(SBTarget self) -> bool

SBTarget_DisableAllWatchpoints(...)
SBTarget_DisableAllWatchpoints(SBTarget self) -> bool

SBTarget_EnableAllBreakpoints(...)
SBTarget_EnableAllBreakpoints(SBTarget self) -> bool

SBTarget_EnableAllWatchpoints(...)
SBTarget_EnableAllWatchpoints(SBTarget self) -> bool

SBTarget_EvaluateExpression(...)
SBTarget_EvaluateExpression(SBTarget self, char const * expr, SBExpressionOptions options) -> SBValue

SBTarget_FindBreakpointByID(...)
SBTarget_FindBreakpointByID(SBTarget self, lldb::break_id_t break_id) -> SBBreakpoint

SBTarget_FindFirstGlobalVariable(...)
SBTarget_FindFirstGlobalVariable(SBTarget self, char const * name) -> SBValue

SBTarget_FindFirstType(...)
SBTarget_FindFirstType(SBTarget self, char const * type) -> SBType

SBTarget_FindFunctions(...)
FindFunctions(char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList SBTarget_FindFunctions(SBTarget self, char const * name) -> SBSymbolContextList

SBTarget_FindGlobalVariables(...)
SBTarget_FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches) -> SBValueList

SBTarget_FindModule(...)
SBTarget_FindModule(SBTarget self, SBFileSpec file_spec) -> SBModule

SBTarget_FindSymbols(...)
FindSymbols(char const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList SBTarget_FindSymbols(SBTarget self, char const * name) -> SBSymbolContextList

SBTarget_FindTypes(...)
SBTarget_FindTypes(SBTarget self, char const * type) -> SBTypeList

SBTarget_FindWatchpointByID(...)
SBTarget_FindWatchpointByID(SBTarget self, lldb::watch_id_t watch_id) -> SBWatchpoint

SBTarget_GetAddressByteSize(...)
SBTarget_GetAddressByteSize(SBTarget self) -> uint32_t

SBTarget_GetBasicType(...)
SBTarget_GetBasicType(SBTarget self, lldb::BasicType type) -> SBType

SBTarget_GetBreakpointAtIndex(...)
SBTarget_GetBreakpointAtIndex(SBTarget self, uint32_t idx) -> SBBreakpoint

SBTarget_GetBroadcaster(...)
SBTarget_GetBroadcaster(SBTarget self) -> SBBroadcaster

char const *

SBTarget_GetBroadcasterClassName()

SBTarget_GetByteOrder(...)
SBTarget_GetByteOrder(SBTarget self) -> lldb::ByteOrder

SBTarget_GetDebugger(...)
SBTarget_GetDebugger(SBTarget self) -> SBDebugger

SBTarget_GetDescription(...)
SBTarget_GetDescription(SBTarget self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTarget_GetExecutable(...)
SBTarget_GetExecutable(SBTarget self) -> SBFileSpec

SBTarget_GetInstructions(...)
SBTarget_GetInstructions(SBTarget self, SBAddress base_addr, void const * buf) -> SBInstructionList

SBTarget_GetInstructionsWithFlavor(...)
SBTarget_GetInstructionsWithFlavor(SBTarget self, SBAddress base_addr, char const * flavor_string, void const * buf) -> SBInstructionList

SBTarget_GetModuleAtIndex(...)
SBTarget_GetModuleAtIndex(SBTarget self, uint32_t idx) -> SBModule

SBTarget_GetNumBreakpoints(...)
SBTarget_GetNumBreakpoints(SBTarget self) -> uint32_t

SBTarget_GetNumModules(...)
SBTarget_GetNumModules(SBTarget self) -> uint32_t

SBTarget_GetNumWatchpoints(...)
SBTarget_GetNumWatchpoints(SBTarget self) -> uint32_t

SBTarget_GetProcess(...)
SBTarget_GetProcess(SBTarget self) -> SBProcess

SBTarget_GetSourceManager(...)
SBTarget_GetSourceManager(SBTarget self) -> SBSourceManager

SBTarget_GetStackRedZoneSize(...)
SBTarget_GetStackRedZoneSize(SBTarget self) -> lldb::addr_t

SBTarget_GetTriple(...)
SBTarget_GetTriple(SBTarget self) -> char const *

SBTarget_GetWatchpointAtIndex(...)
SBTarget_GetWatchpointAtIndex(SBTarget self, uint32_t idx) -> SBWatchpoint

SBTarget_IsValid(...)
SBTarget_IsValid(SBTarget self) -> bool

SBTarget_Launch(...)
Launch(SBListener listener, char const ** argv, char const ** envp, char const * stdin_path, char const * stdout_path, char const * stderr_path, char const * working_directory, uint32_t launch_flags, bool stop_at_entry, SBError error) -> SBProcess SBTarget_Launch(SBTarget self, SBLaunchInfo launch_info, SBError error) -> SBProcess

SBTarget_LaunchSimple(...)
SBTarget_LaunchSimple(SBTarget self, char const ** argv, char const ** envp, char const * working_directory) -> SBProcess

SBTarget_LoadCore(...)
SBTarget_LoadCore(SBTarget self, char const * core_file) -> SBProcess

SBTarget_ReadInstructions(...)
ReadInstructions(SBAddress base_addr, uint32_t count) -> SBInstructionList SBTarget_ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count, char const * flavor_string) -> SBInstructionList

SBTarget_RemoveModule(...)
SBTarget_RemoveModule(SBTarget self, SBModule module) -> bool

SBTarget_ResolveLoadAddress(...)
SBTarget_ResolveLoadAddress(SBTarget self, lldb::addr_t vm_addr) -> SBAddress

SBTarget_ResolveSymbolContextForAddress(...)
SBTarget_ResolveSymbolContextForAddress(SBTarget self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext

SBTarget_SetModuleLoadAddress(...)
SBTarget_SetModuleLoadAddress(SBTarget self, SBModule module, int64_t sections_offset) -> SBError

SBTarget_SetSectionLoadAddress(...)
SBTarget_SetSectionLoadAddress(SBTarget self, SBSection section, lldb::addr_t section_base_addr) -> SBError

SBTarget_WatchAddress(...)
SBTarget_WatchAddress(SBTarget self, lldb::addr_t addr, size_t size, bool read, bool write, SBError error) -> SBWatchpoint

SBTarget___eq__(...)
SBTarget___eq__(SBTarget self, SBTarget rhs) -> bool

SBTarget___ne__(...)
SBTarget___ne__(SBTarget self, SBTarget rhs) -> bool

SBTarget___str__(...)
SBTarget___str__(SBTarget self) -> PyObject *

SBTarget_swigregister(...)

SBThread_Clear(...)
SBThread_Clear(SBThread self)

SBThread_EventIsThreadEvent(...)
SBThread_EventIsThreadEvent(SBEvent event) -> bool

SBThread_GetDescription(...)
SBThread_GetDescription(SBThread self, SBStream description) -> bool

SBThread_GetFrameAtIndex(...)
SBThread_GetFrameAtIndex(SBThread self, uint32_t idx) -> SBFrame

SBThread_GetIndexID(...)
SBThread_GetIndexID(SBThread self) -> uint32_t

SBThread_GetName(...)
SBThread_GetName(SBThread self) -> char const *

SBThread_GetNumFrames(...)
SBThread_GetNumFrames(SBThread self) -> uint32_t

SBThread_GetProcess(...)
SBThread_GetProcess(SBThread self) -> SBProcess

SBThread_GetQueueName(...)
SBThread_GetQueueName(SBThread self) -> char const *

SBThread_GetSelectedFrame(...)
SBThread_GetSelectedFrame(SBThread self) -> SBFrame

SBThread_GetStackFrameFromEvent(...)
SBThread_GetStackFrameFromEvent(SBEvent event) -> SBFrame

SBThread_GetStatus(...)
SBThread_GetStatus(SBThread self, SBStream status) -> bool

SBThread_GetStopDescription(...)
Pass only an (int)length and expect to get a Python string describing the stop reason.

SBThread_GetStopReason(...)
SBThread_GetStopReason(SBThread self) -> lldb::StopReason

SBThread_GetStopReasonDataAtIndex(...)
SBThread_GetStopReasonDataAtIndex(SBThread self, uint32_t idx) -> uint64_t

SBThread_GetStopReasonDataCount(...)
SBThread_GetStopReasonDataCount(SBThread self) -> size_t

SBThread_GetStopReturnValue(...)
SBThread_GetStopReturnValue(SBThread self) -> SBValue

SBThread_GetThreadFromEvent(...)
SBThread_GetThreadFromEvent(SBEvent event) -> SBThread

SBThread_GetThreadID(...)
SBThread_GetThreadID(SBThread self) -> lldb::tid_t

SBThread_IsStopped(...)
SBThread_IsStopped(SBThread self) -> bool

SBThread_IsSuspended(...)
SBThread_IsSuspended(SBThread self) -> bool

SBThread_IsValid(...)
SBThread_IsValid(SBThread self) -> bool

SBThread_Resume(...)
SBThread_Resume(SBThread self) -> bool

SBThread_ReturnFromFrame(...)
SBThread_ReturnFromFrame(SBThread self, SBFrame frame, SBValue return_value) -> SBError

SBThread_RunToAddress(...)
SBThread_RunToAddress(SBThread self, lldb::addr_t addr)

SBThread_SetSelectedFrame(...)
SBThread_SetSelectedFrame(SBThread self, uint32_t frame_idx) -> SBFrame

SBThread_StepInstruction(...)
SBThread_StepInstruction(SBThread self, bool step_over)

SBThread_StepInto(...)
StepInto(lldb::RunMode stop_other_threads=eOnlyDuringStepping) StepInto() StepInto(char const * target_name, lldb::RunMode stop_other_threads=eOnlyDuringStepping) SBThread_StepInto(SBThread self, char const * target_name)

SBThread_StepOut(...)
SBThread_StepOut(SBThread self)

SBThread_StepOutOfFrame(...)
SBThread_StepOutOfFrame(SBThread self, SBFrame frame)

SBThread_StepOver(...)
StepOver(lldb::RunMode stop_other_threads=eOnlyDuringStepping) SBThread_StepOver(SBThread self)

SBThread_StepOverUntil(...)
SBThread_StepOverUntil(SBThread self, SBFrame frame, SBFileSpec file_spec, uint32_t line) -> SBError

SBThread_Suspend(...)
SBThread_Suspend(SBThread self) -> bool

SBThread___eq__(...)
SBThread___eq__(SBThread self, SBThread rhs) -> bool

SBThread___ne__(...)
SBThread___ne__(SBThread self, SBThread rhs) -> bool

SBThread___str__(...)
SBThread___str__(SBThread self) -> PyObject *

SBThread_swigregister(...)

SBTypeCategory_AddTypeFilter(...)
SBTypeCategory_AddTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFilter arg3) -> bool

SBTypeCategory_AddTypeFormat(...)
SBTypeCategory_AddTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeFormat arg3) -> bool

SBTypeCategory_AddTypeSummary(...)
SBTypeCategory_AddTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSummary arg3) -> bool

SBTypeCategory_AddTypeSynthetic(...)
SBTypeCategory_AddTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2, SBTypeSynthetic arg3) -> bool

SBTypeCategory_DeleteTypeFilter(...)
SBTypeCategory_DeleteTypeFilter(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool

SBTypeCategory_DeleteTypeFormat(...)
SBTypeCategory_DeleteTypeFormat(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool

SBTypeCategory_DeleteTypeSummary(...)
SBTypeCategory_DeleteTypeSummary(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool

SBTypeCategory_DeleteTypeSynthetic(...)
SBTypeCategory_DeleteTypeSynthetic(SBTypeCategory self, SBTypeNameSpecifier arg2) -> bool

SBTypeCategory_GetDescription(...)
SBTypeCategory_GetDescription(SBTypeCategory self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeCategory_GetEnabled(...)
SBTypeCategory_GetEnabled(SBTypeCategory self) -> bool

SBTypeCategory_GetFilterAtIndex(...)
SBTypeCategory_GetFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFilter

SBTypeCategory_GetFilterForType(...)
SBTypeCategory_GetFilterForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFilter

SBTypeCategory_GetFormatAtIndex(...)
SBTypeCategory_GetFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeFormat

SBTypeCategory_GetFormatForType(...)
SBTypeCategory_GetFormatForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeFormat

SBTypeCategory_GetName(...)
SBTypeCategory_GetName(SBTypeCategory self) -> char const *

SBTypeCategory_GetNumFilters(...)
SBTypeCategory_GetNumFilters(SBTypeCategory self) -> uint32_t

SBTypeCategory_GetNumFormats(...)
SBTypeCategory_GetNumFormats(SBTypeCategory self) -> uint32_t

SBTypeCategory_GetNumSummaries(...)
SBTypeCategory_GetNumSummaries(SBTypeCategory self) -> uint32_t

SBTypeCategory_GetNumSynthetics(...)
SBTypeCategory_GetNumSynthetics(SBTypeCategory self) -> uint32_t

SBTypeCategory_GetSummaryAtIndex(...)
SBTypeCategory_GetSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSummary

SBTypeCategory_GetSummaryForType(...)
SBTypeCategory_GetSummaryForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSummary

SBTypeCategory_GetSyntheticAtIndex(...)
SBTypeCategory_GetSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeSynthetic

SBTypeCategory_GetSyntheticForType(...)
SBTypeCategory_GetSyntheticForType(SBTypeCategory self, SBTypeNameSpecifier arg2) -> SBTypeSynthetic

SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(...)
SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier

SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(...)
SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier

SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(...)
SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier

SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(...)
SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(SBTypeCategory self, uint32_t arg2) -> SBTypeNameSpecifier

SBTypeCategory_IsValid(...)
SBTypeCategory_IsValid(SBTypeCategory self) -> bool

SBTypeCategory_SetEnabled(...)
SBTypeCategory_SetEnabled(SBTypeCategory self, bool arg2)

SBTypeCategory___str__(...)
SBTypeCategory___str__(SBTypeCategory self) -> PyObject *

SBTypeCategory_swigregister(...)

SBTypeFilter_AppendExpressionPath(...)
SBTypeFilter_AppendExpressionPath(SBTypeFilter self, char const * item)

SBTypeFilter_Clear(...)
SBTypeFilter_Clear(SBTypeFilter self)

SBTypeFilter_GetDescription(...)
SBTypeFilter_GetDescription(SBTypeFilter self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeFilter_GetExpressionPathAtIndex(...)
SBTypeFilter_GetExpressionPathAtIndex(SBTypeFilter self, uint32_t i) -> char const *

SBTypeFilter_GetNumberOfExpressionPaths(...)
SBTypeFilter_GetNumberOfExpressionPaths(SBTypeFilter self) -> uint32_t

SBTypeFilter_GetOptions(...)
SBTypeFilter_GetOptions(SBTypeFilter self) -> uint32_t

SBTypeFilter_IsEqualTo(...)
SBTypeFilter_IsEqualTo(SBTypeFilter self, SBTypeFilter rhs) -> bool

SBTypeFilter_IsValid(...)
SBTypeFilter_IsValid(SBTypeFilter self) -> bool

SBTypeFilter_ReplaceExpressionPathAtIndex(...)
SBTypeFilter_ReplaceExpressionPathAtIndex(SBTypeFilter self, uint32_t i, char const * item) -> bool

SBTypeFilter_SetOptions(...)
SBTypeFilter_SetOptions(SBTypeFilter self, uint32_t arg2)

SBTypeFilter___eq__(...)
SBTypeFilter___eq__(SBTypeFilter self, SBTypeFilter rhs) -> bool

SBTypeFilter___ne__(...)
SBTypeFilter___ne__(SBTypeFilter self, SBTypeFilter rhs) -> bool

SBTypeFilter___str__(...)
SBTypeFilter___str__(SBTypeFilter self) -> PyObject *

SBTypeFilter_swigregister(...)

SBTypeFormat_GetDescription(...)
SBTypeFormat_GetDescription(SBTypeFormat self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeFormat_GetFormat(...)
SBTypeFormat_GetFormat(SBTypeFormat self) -> lldb::Format

SBTypeFormat_GetOptions(...)
SBTypeFormat_GetOptions(SBTypeFormat self) -> uint32_t

SBTypeFormat_IsEqualTo(...)
SBTypeFormat_IsEqualTo(SBTypeFormat self, SBTypeFormat rhs) -> bool

SBTypeFormat_IsValid(...)
SBTypeFormat_IsValid(SBTypeFormat self) -> bool

SBTypeFormat_SetFormat(...)
SBTypeFormat_SetFormat(SBTypeFormat self, lldb::Format arg2)

SBTypeFormat_SetOptions(...)
SBTypeFormat_SetOptions(SBTypeFormat self, uint32_t arg2)

SBTypeFormat___eq__(...)
SBTypeFormat___eq__(SBTypeFormat self, SBTypeFormat rhs) -> bool

SBTypeFormat___ne__(...)
SBTypeFormat___ne__(SBTypeFormat self, SBTypeFormat rhs) -> bool

SBTypeFormat___str__(...)
SBTypeFormat___str__(SBTypeFormat self) -> PyObject *

SBTypeFormat_swigregister(...)

SBTypeList_Append(...)
SBTypeList_Append(SBTypeList self, SBType type)

SBTypeList_GetSize(...)
SBTypeList_GetSize(SBTypeList self) -> uint32_t

SBTypeList_GetTypeAtIndex(...)
SBTypeList_GetTypeAtIndex(SBTypeList self, uint32_t index) -> SBType

SBTypeList_IsValid(...)
SBTypeList_IsValid(SBTypeList self) -> bool

SBTypeList_swigregister(...)

SBTypeMember_GetBitfieldSizeInBits(...)
SBTypeMember_GetBitfieldSizeInBits(SBTypeMember self) -> uint32_t

SBTypeMember_GetName(...)
SBTypeMember_GetName(SBTypeMember self) -> char const *

SBTypeMember_GetOffsetInBits(...)
SBTypeMember_GetOffsetInBits(SBTypeMember self) -> uint64_t

SBTypeMember_GetOffsetInBytes(...)
SBTypeMember_GetOffsetInBytes(SBTypeMember self) -> uint64_t

SBTypeMember_GetType(...)
SBTypeMember_GetType(SBTypeMember self) -> SBType

SBTypeMember_IsBitfield(...)
SBTypeMember_IsBitfield(SBTypeMember self) -> bool

SBTypeMember_IsValid(...)
SBTypeMember_IsValid(SBTypeMember self) -> bool

SBTypeMember___str__(...)
SBTypeMember___str__(SBTypeMember self) -> PyObject *

SBTypeMember_swigregister(...)

SBTypeNameSpecifier_GetDescription(...)
SBTypeNameSpecifier_GetDescription(SBTypeNameSpecifier self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeNameSpecifier_GetName(...)
SBTypeNameSpecifier_GetName(SBTypeNameSpecifier self) -> char const *

SBTypeNameSpecifier_GetType(...)
SBTypeNameSpecifier_GetType(SBTypeNameSpecifier self) -> SBType

SBTypeNameSpecifier_IsEqualTo(...)
SBTypeNameSpecifier_IsEqualTo(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool

SBTypeNameSpecifier_IsRegex(...)
SBTypeNameSpecifier_IsRegex(SBTypeNameSpecifier self) -> bool

SBTypeNameSpecifier_IsValid(...)
SBTypeNameSpecifier_IsValid(SBTypeNameSpecifier self) -> bool

SBTypeNameSpecifier___eq__(...)
SBTypeNameSpecifier___eq__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool

SBTypeNameSpecifier___ne__(...)
SBTypeNameSpecifier___ne__(SBTypeNameSpecifier self, SBTypeNameSpecifier rhs) -> bool

SBTypeNameSpecifier___str__(...)
SBTypeNameSpecifier___str__(SBTypeNameSpecifier self) -> PyObject *

SBTypeNameSpecifier_swigregister(...)

SBTypeSummary_CreateWithFunctionName(...)
CreateWithFunctionName(char const * data, uint32_t options=0) -> SBTypeSummary SBTypeSummary_CreateWithFunctionName(char const * data) -> SBTypeSummary

SBTypeSummary_CreateWithScriptCode(...)
CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSummary SBTypeSummary_CreateWithScriptCode(char const * data) -> SBTypeSummary

SBTypeSummary_CreateWithSummaryString(...)
CreateWithSummaryString(char const * data, uint32_t options=0) -> SBTypeSummary SBTypeSummary_CreateWithSummaryString(char const * data) -> SBTypeSummary

SBTypeSummary_GetData(...)
SBTypeSummary_GetData(SBTypeSummary self) -> char const *

SBTypeSummary_GetDescription(...)
SBTypeSummary_GetDescription(SBTypeSummary self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeSummary_GetOptions(...)
SBTypeSummary_GetOptions(SBTypeSummary self) -> uint32_t

SBTypeSummary_IsEqualTo(...)
SBTypeSummary_IsEqualTo(SBTypeSummary self, SBTypeSummary rhs) -> bool

SBTypeSummary_IsFunctionCode(...)
SBTypeSummary_IsFunctionCode(SBTypeSummary self) -> bool

SBTypeSummary_IsFunctionName(...)
SBTypeSummary_IsFunctionName(SBTypeSummary self) -> bool

SBTypeSummary_IsSummaryString(...)
SBTypeSummary_IsSummaryString(SBTypeSummary self) -> bool

SBTypeSummary_IsValid(...)
SBTypeSummary_IsValid(SBTypeSummary self) -> bool

SBTypeSummary_SetFunctionCode(...)
SBTypeSummary_SetFunctionCode(SBTypeSummary self, char const * data)

SBTypeSummary_SetFunctionName(...)
SBTypeSummary_SetFunctionName(SBTypeSummary self, char const * data)

SBTypeSummary_SetOptions(...)
SBTypeSummary_SetOptions(SBTypeSummary self, uint32_t arg2)

SBTypeSummary_SetSummaryString(...)
SBTypeSummary_SetSummaryString(SBTypeSummary self, char const * data)

SBTypeSummary___eq__(...)
SBTypeSummary___eq__(SBTypeSummary self, SBTypeSummary rhs) -> bool

SBTypeSummary___ne__(...)
SBTypeSummary___ne__(SBTypeSummary self, SBTypeSummary rhs) -> bool

SBTypeSummary___str__(...)
SBTypeSummary___str__(SBTypeSummary self) -> PyObject *

SBTypeSummary_swigregister(...)

SBTypeSynthetic_CreateWithClassName(...)
CreateWithClassName(char const * data, uint32_t options=0) -> SBTypeSynthetic SBTypeSynthetic_CreateWithClassName(char const * data) -> SBTypeSynthetic

SBTypeSynthetic_CreateWithScriptCode(...)
CreateWithScriptCode(char const * data, uint32_t options=0) -> SBTypeSynthetic SBTypeSynthetic_CreateWithScriptCode(char const * data) -> SBTypeSynthetic

SBTypeSynthetic_GetData(...)
SBTypeSynthetic_GetData(SBTypeSynthetic self) -> char const *

SBTypeSynthetic_GetDescription(...)
SBTypeSynthetic_GetDescription(SBTypeSynthetic self, SBStream description, lldb::DescriptionLevel description_level) -> bool

SBTypeSynthetic_GetOptions(...)
SBTypeSynthetic_GetOptions(SBTypeSynthetic self) -> uint32_t

SBTypeSynthetic_IsClassCode(...)
SBTypeSynthetic_IsClassCode(SBTypeSynthetic self) -> bool

SBTypeSynthetic_IsEqualTo(...)
SBTypeSynthetic_IsEqualTo(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool

SBTypeSynthetic_IsValid(...)
SBTypeSynthetic_IsValid(SBTypeSynthetic self) -> bool

SBTypeSynthetic_SetClassCode(...)
SBTypeSynthetic_SetClassCode(SBTypeSynthetic self, char const * data)

SBTypeSynthetic_SetClassName(...)
SBTypeSynthetic_SetClassName(SBTypeSynthetic self, char const * data)

SBTypeSynthetic_SetOptions(...)
SBTypeSynthetic_SetOptions(SBTypeSynthetic self, uint32_t arg2)

SBTypeSynthetic___eq__(...)
SBTypeSynthetic___eq__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool

SBTypeSynthetic___ne__(...)
SBTypeSynthetic___ne__(SBTypeSynthetic self, SBTypeSynthetic rhs) -> bool

SBTypeSynthetic___str__(...)
SBTypeSynthetic___str__(SBTypeSynthetic self) -> PyObject *

SBTypeSynthetic_swigregister(...)

lldb::BasicType

SBType_GetBasicType()
SBType_GetBasicType(SBType self, lldb::BasicType type) -> SBType

SBType_GetByteSize(...)
SBType_GetByteSize(SBType self) -> uint64_t

SBType_GetCanonicalType(...)
SBType_GetCanonicalType(SBType self) -> SBType

SBType_GetDereferencedType(...)
SBType_GetDereferencedType(SBType self) -> SBType

SBType_GetDirectBaseClassAtIndex(...)
SBType_GetDirectBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember

SBType_GetFieldAtIndex(...)
SBType_GetFieldAtIndex(SBType self, uint32_t idx) -> SBTypeMember

SBType_GetFunctionArgumentTypes(...)
SBType_GetFunctionArgumentTypes(SBType self) -> SBTypeList

SBType_GetFunctionReturnType(...)
SBType_GetFunctionReturnType(SBType self) -> SBType

SBType_GetName(...)
SBType_GetName(SBType self) -> char const *

SBType_GetNumberOfDirectBaseClasses(...)
SBType_GetNumberOfDirectBaseClasses(SBType self) -> uint32_t

SBType_GetNumberOfFields(...)
SBType_GetNumberOfFields(SBType self) -> uint32_t

SBType_GetNumberOfTemplateArguments(...)
SBType_GetNumberOfTemplateArguments(SBType self) -> uint32_t

SBType_GetNumberOfVirtualBaseClasses(...)
SBType_GetNumberOfVirtualBaseClasses(SBType self) -> uint32_t

SBType_GetPointeeType(...)
SBType_GetPointeeType(SBType self) -> SBType

SBType_GetPointerType(...)
SBType_GetPointerType(SBType self) -> SBType

SBType_GetReferenceType(...)
SBType_GetReferenceType(SBType self) -> SBType

SBType_GetTemplateArgumentKind(...)
SBType_GetTemplateArgumentKind(SBType self, uint32_t idx) -> lldb::TemplateArgumentKind

SBType_GetTemplateArgumentType(...)
SBType_GetTemplateArgumentType(SBType self, uint32_t idx) -> SBType

SBType_GetTypeClass(...)
SBType_GetTypeClass(SBType self) -> lldb::TypeClass

SBType_GetUnqualifiedType(...)
SBType_GetUnqualifiedType(SBType self) -> SBType

SBType_GetVirtualBaseClassAtIndex(...)
SBType_GetVirtualBaseClassAtIndex(SBType self, uint32_t idx) -> SBTypeMember

SBType_IsFunctionType(...)
SBType_IsFunctionType(SBType self) -> bool

SBType_IsPointerType(...)
SBType_IsPointerType(SBType self) -> bool

SBType_IsPolymorphicClass(...)
SBType_IsPolymorphicClass(SBType self) -> bool

SBType_IsReferenceType(...)
SBType_IsReferenceType(SBType self) -> bool

SBType_IsTypeComplete(...)
SBType_IsTypeComplete(SBType self) -> bool

SBType_IsValid(...)
SBType_IsValid(SBType self) -> bool

SBType___str__(...)
SBType___str__(SBType self) -> PyObject *

SBType_swigregister(...)

SBValueList_Append(...)
Append(SBValue val_obj) SBValueList_Append(SBValueList self, SBValueList value_list)

SBValueList_Clear(...)
SBValueList_Clear(SBValueList self)

SBValueList_FindValueObjectByUID(...)
SBValueList_FindValueObjectByUID(SBValueList self, lldb::user_id_t uid) -> SBValue

SBValueList_GetSize(...)
SBValueList_GetSize(SBValueList self) -> uint32_t

SBValueList_GetValueAtIndex(...)
SBValueList_GetValueAtIndex(SBValueList self, uint32_t idx) -> SBValue

SBValueList_IsValid(...)
SBValueList_IsValid(SBValueList self) -> bool

SBValueList___str__(...)
SBValueList___str__(SBValueList self) -> PyObject *

SBValueList_swigregister(...)

SBValue_AddressOf(...)
SBValue_AddressOf(SBValue self) -> SBValue

SBValue_Cast(...)
SBValue_Cast(SBValue self, SBType type) -> SBValue

SBValue_Clear(...)
SBValue_Clear(SBValue self)

SBValue_CreateChildAtOffset(...)
SBValue_CreateChildAtOffset(SBValue self, char const * name, uint32_t offset, SBType type) -> SBValue

SBValue_CreateValueFromAddress(...)
SBValue_CreateValueFromAddress(SBValue self, char const * name, lldb::addr_t address, SBType type) -> SBValue

SBValue_CreateValueFromData(...)
SBValue_CreateValueFromData(SBValue self, char const * name, SBData data, SBType type) -> SBValue

SBValue_CreateValueFromExpression(...)
CreateValueFromExpression(char const * name, char const * expression) -> SBValue SBValue_CreateValueFromExpression(SBValue self, char const * name, char const * expression, SBExpressionOptions options) -> SBValue

SBValue_Dereference(...)
SBValue_Dereference(SBValue self) -> SBValue

SBValue_GetAddress(...)
SBValue_GetAddress(SBValue self) -> SBAddress

SBValue_GetByteSize(...)
SBValue_GetByteSize(SBValue self) -> size_t

SBValue_GetChildAtIndex(...)
GetChildAtIndex(uint32_t idx) -> SBValue SBValue_GetChildAtIndex(SBValue self, uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) -> SBValue

SBValue_GetChildMemberWithName(...)
GetChildMemberWithName(char const * name) -> SBValue SBValue_GetChildMemberWithName(SBValue self, char const * name, lldb::DynamicValueType use_dynamic) -> SBValue

SBValue_GetData(...)
SBValue_GetData(SBValue self) -> SBData

SBValue_GetDeclaration(...)
SBValue_GetDeclaration(SBValue self) -> SBDeclaration

SBValue_GetDescription(...)
SBValue_GetDescription(SBValue self, SBStream description) -> bool

SBValue_GetDynamicValue(...)
SBValue_GetDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic) -> SBValue

SBValue_GetError(...)
SBValue_GetError(SBValue self) -> SBError

SBValue_GetExpressionPath(...)
GetExpressionPath(SBStream description) -> bool SBValue_GetExpressionPath(SBValue self, SBStream description, bool qualify_cxx_base_classes) -> bool

SBValue_GetFormat(...)
SBValue_GetFormat(SBValue self) -> lldb::Format

SBValue_GetFrame(...)
SBValue_GetFrame(SBValue self) -> SBFrame

SBValue_GetID(...)
SBValue_GetID(SBValue self) -> lldb::user_id_t

SBValue_GetIndexOfChildWithName(...)
SBValue_GetIndexOfChildWithName(SBValue self, char const * name) -> uint32_t

SBValue_GetLoadAddress(...)
SBValue_GetLoadAddress(SBValue self) -> lldb::addr_t

SBValue_GetLocation(...)
SBValue_GetLocation(SBValue self) -> char const *

SBValue_GetName(...)
SBValue_GetName(SBValue self) -> char const *

SBValue_GetNonSyntheticValue(...)
SBValue_GetNonSyntheticValue(SBValue self) -> SBValue

SBValue_GetNumChildren(...)
SBValue_GetNumChildren(SBValue self) -> uint32_t

SBValue_GetObjectDescription(...)
SBValue_GetObjectDescription(SBValue self) -> char const *

SBValue_GetOpaqueType(...)
SBValue_GetOpaqueType(SBValue self) -> void *

SBValue_GetPointeeData(...)
GetPointeeData(uint32_t item_idx=0, uint32_t item_count=1) -> SBData GetPointeeData(uint32_t item_idx=0) -> SBData SBValue_GetPointeeData(SBValue self) -> SBData

SBValue_GetPreferDynamicValue(...)
SBValue_GetPreferDynamicValue(SBValue self) -> lldb::DynamicValueType

SBValue_GetPreferSyntheticValue(...)
SBValue_GetPreferSyntheticValue(SBValue self) -> bool

SBValue_GetProcess(...)
SBValue_GetProcess(SBValue self) -> SBProcess

SBValue_GetStaticValue(...)
SBValue_GetStaticValue(SBValue self) -> SBValue

SBValue_GetSummary(...)
SBValue_GetSummary(SBValue self) -> char const *

SBValue_GetTarget(...)
SBValue_GetTarget(SBValue self) -> SBTarget

SBValue_GetThread(...)
SBValue_GetThread(SBValue self) -> SBThread

SBValue_GetType(...)
SBValue_GetType(SBValue self) -> SBType

SBValue_GetTypeFilter(...)
SBValue_GetTypeFilter(SBValue self) -> SBTypeFilter

SBValue_GetTypeFormat(...)
SBValue_GetTypeFormat(SBValue self) -> SBTypeFormat

SBValue_GetTypeName(...)
SBValue_GetTypeName(SBValue self) -> char const *

SBValue_GetTypeSummary(...)
SBValue_GetTypeSummary(SBValue self) -> SBTypeSummary

SBValue_GetTypeSynthetic(...)
SBValue_GetTypeSynthetic(SBValue self) -> SBTypeSynthetic

SBValue_GetValue(...)
SBValue_GetValue(SBValue self) -> char const *

SBValue_GetValueAsSigned(...)
GetValueAsSigned(SBError error, int64_t fail_value=0) -> int64_t GetValueAsSigned(SBError error) -> int64_t GetValueAsSigned(int64_t fail_value=0) -> int64_t SBValue_GetValueAsSigned(SBValue self) -> int64_t

SBValue_GetValueAsUnsigned(...)
GetValueAsUnsigned(SBError error, uint64_t fail_value=0) -> uint64_t GetValueAsUnsigned(SBError error) -> uint64_t GetValueAsUnsigned(uint64_t fail_value=0) -> uint64_t SBValue_GetValueAsUnsigned(SBValue self) -> uint64_t

SBValue_GetValueDidChange(...)
SBValue_GetValueDidChange(SBValue self) -> bool

SBValue_GetValueForExpressionPath(...)
SBValue_GetValueForExpressionPath(SBValue self, char const * expr_path) -> SBValue

SBValue_GetValueType(...)
SBValue_GetValueType(SBValue self) -> lldb::ValueType

SBValue_IsDynamic(...)
SBValue_IsDynamic(SBValue self) -> bool

SBValue_IsInScope(...)
SBValue_IsInScope(SBValue self) -> bool

SBValue_IsSynthetic(...)
SBValue_IsSynthetic(SBValue self) -> bool

SBValue_IsValid(...)
SBValue_IsValid(SBValue self) -> bool

SBValue_MightHaveChildren(...)
SBValue_MightHaveChildren(SBValue self) -> bool

SBValue_SetData(...)
SBValue_SetData(SBValue self, SBData data, SBError error) -> bool

SBValue_SetFormat(...)
SBValue_SetFormat(SBValue self, lldb::Format format)

SBValue_SetPreferDynamicValue(...)
SBValue_SetPreferDynamicValue(SBValue self, lldb::DynamicValueType use_dynamic)

SBValue_SetPreferSyntheticValue(...)
SBValue_SetPreferSyntheticValue(SBValue self, bool use_synthetic)

SBValue_SetValueFromCString(...)
SetValueFromCString(char const * value_str) -> bool SBValue_SetValueFromCString(SBValue self, char const * value_str, SBError error) -> bool

SBValue_TypeIsPointerType(...)
SBValue_TypeIsPointerType(SBValue self) -> bool

SBValue_Watch(...)
SBValue_Watch(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint

SBValue_WatchPointee(...)
SBValue_WatchPointee(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint

SBValue___str__(...)
SBValue___str__(SBValue self) -> PyObject *

SBValue_swigregister(...)

SBWatchpoint_EventIsWatchpointEvent(...)
SBWatchpoint_EventIsWatchpointEvent(SBEvent event) -> bool

SBWatchpoint_GetCondition(...)
SBWatchpoint_GetCondition(SBWatchpoint self) -> char const *

SBWatchpoint_GetDescription(...)
SBWatchpoint_GetDescription(SBWatchpoint self, SBStream description, lldb::DescriptionLevel level) -> bool

SBWatchpoint_GetError(...)
SBWatchpoint_GetError(SBWatchpoint self) -> SBError

SBWatchpoint_GetHardwareIndex(...)
SBWatchpoint_GetHardwareIndex(SBWatchpoint self) -> int32_t

SBWatchpoint_GetHitCount(...)
SBWatchpoint_GetHitCount(SBWatchpoint self) -> uint32_t

SBWatchpoint_GetID(...)
SBWatchpoint_GetID(SBWatchpoint self) -> lldb::watch_id_t

SBWatchpoint_GetIgnoreCount(...)
SBWatchpoint_GetIgnoreCount(SBWatchpoint self) -> uint32_t

SBWatchpoint_GetWatchAddress(...)
SBWatchpoint_GetWatchAddress(SBWatchpoint self) -> lldb::addr_t

SBWatchpoint_GetWatchSize(...)
SBWatchpoint_GetWatchSize(SBWatchpoint self) -> size_t

SBWatchpoint_GetWatchpointEventTypeFromEvent(...)
SBWatchpoint_GetWatchpointEventTypeFromEvent(SBEvent event) -> lldb::WatchpointEventType

SBWatchpoint_GetWatchpointFromEvent(...)
SBWatchpoint_GetWatchpointFromEvent(SBEvent event) -> SBWatchpoint

SBWatchpoint_IsEnabled(...)
SBWatchpoint_IsEnabled(SBWatchpoint self) -> bool

SBWatchpoint_IsValid(...)
SBWatchpoint_IsValid(SBWatchpoint self) -> bool

SBWatchpoint_SetCondition(...)
SBWatchpoint_SetCondition(SBWatchpoint self, char const * condition)

SBWatchpoint_SetEnabled(...)
SBWatchpoint_SetEnabled(SBWatchpoint self, bool enabled)

SBWatchpoint_SetIgnoreCount(...)
SBWatchpoint_SetIgnoreCount(SBWatchpoint self, uint32_t n)

SBWatchpoint___str__(...)
SBWatchpoint___str__(SBWatchpoint self) -> PyObject *

SBWatchpoint_swigregister(...)

SWIG_PyInstanceMethod_New(...)

delete_SBAddress(...)
delete_SBAddress(SBAddress self)

delete_SBAttachInfo(...)
delete_SBAttachInfo(SBAttachInfo self)

delete_SBBlock(...)
delete_SBBlock(SBBlock self)

delete_SBBreakpoint(...)
delete_SBBreakpoint(SBBreakpoint self)

delete_SBBreakpointLocation(...)
delete_SBBreakpointLocation(SBBreakpointLocation self)

delete_SBBroadcaster(...)
delete_SBBroadcaster(SBBroadcaster self)

delete_SBCommandInterpreter(...)
delete_SBCommandInterpreter(SBCommandInterpreter self)

delete_SBCommandReturnObject(...)
delete_SBCommandReturnObject(SBCommandReturnObject self)

delete_SBCommunication(...)
delete_SBCommunication(SBCommunication self)

delete_SBCompileUnit(...)
delete_SBCompileUnit(SBCompileUnit self)

delete_SBData(...)
delete_SBData(SBData self)

delete_SBDebugger(...)
delete_SBDebugger(SBDebugger self)

delete_SBDeclaration(...)
delete_SBDeclaration(SBDeclaration self)

delete_SBError(...)
delete_SBError(SBError self)

delete_SBEvent(...)
delete_SBEvent(SBEvent self)

delete_SBExpressionOptions(...)
delete_SBExpressionOptions(SBExpressionOptions self)

delete_SBFileSpec(...)
delete_SBFileSpec(SBFileSpec self)

delete_SBFileSpecList(...)
delete_SBFileSpecList(SBFileSpecList self)

delete_SBFrame(...)
delete_SBFrame(SBFrame self)

delete_SBFunction(...)
delete_SBFunction(SBFunction self)

delete_SBHostOS(...)
delete_SBHostOS(SBHostOS self)

delete_SBInputReader(...)
delete_SBInputReader(SBInputReader self)

delete_SBInstruction(...)
delete_SBInstruction(SBInstruction self)

delete_SBInstructionList(...)
delete_SBInstructionList(SBInstructionList self)

delete_SBLaunchInfo(...)
delete_SBLaunchInfo(SBLaunchInfo self)

delete_SBLineEntry(...)
delete_SBLineEntry(SBLineEntry self)

delete_SBListener(...)
delete_SBListener(SBListener self)

delete_SBModule(...)
delete_SBModule(SBModule self)

delete_SBModuleSpec(...)
delete_SBModuleSpec(SBModuleSpec self)

delete_SBModuleSpecList(...)
delete_SBModuleSpecList(SBModuleSpecList self)

delete_SBProcess(...)
delete_SBProcess(SBProcess self)

delete_SBSection(...)
delete_SBSection(SBSection self)

delete_SBSourceManager(...)
delete_SBSourceManager(SBSourceManager self)

delete_SBStream(...)
delete_SBStream(SBStream self)

delete_SBStringList(...)
delete_SBStringList(SBStringList self)

delete_SBSymbol(...)
delete_SBSymbol(SBSymbol self)

delete_SBSymbolContext(...)
delete_SBSymbolContext(SBSymbolContext self)

delete_SBSymbolContextList(...)
delete_SBSymbolContextList(SBSymbolContextList self)

delete_SBTarget(...)
delete_SBTarget(SBTarget self)

delete_SBThread(...)
delete_SBThread(SBThread self)

delete_SBType(...)
delete_SBType(SBType self)

delete_SBTypeCategory(...)
delete_SBTypeCategory(SBTypeCategory self)

delete_SBTypeFilter(...)
delete_SBTypeFilter(SBTypeFilter self)

delete_SBTypeFormat(...)
delete_SBTypeFormat(SBTypeFormat self)

delete_SBTypeList(...)
delete_SBTypeList(SBTypeList self)

delete_SBTypeMember(...)
delete_SBTypeMember(SBTypeMember self)

delete_SBTypeNameSpecifier(...)
delete_SBTypeNameSpecifier(SBTypeNameSpecifier self)

delete_SBTypeSummary(...)
delete_SBTypeSummary(SBTypeSummary self)

delete_SBTypeSynthetic(...)
delete_SBTypeSynthetic(SBTypeSynthetic self)

delete_SBValue(...)
delete_SBValue(SBValue self)

delete_SBValueList(...)
delete_SBValueList(SBValueList self)

delete_SBWatchpoint(...)
delete_SBWatchpoint(SBWatchpoint self)

new_SBAddress()
SBAddress(SBAddress rhs) SBAddress(SBSection section, lldb::addr_t offset) new_SBAddress(lldb::addr_t load_addr, SBTarget target) -> SBAddress

new_SBAttachInfo()
SBAttachInfo(lldb::pid_t pid) SBAttachInfo(char const * path, bool wait_for) new_SBAttachInfo(SBAttachInfo rhs) -> SBAttachInfo

new_SBBlock()
new_SBBlock(SBBlock rhs) -> SBBlock

new_SBBreakpoint()
new_SBBreakpoint(SBBreakpoint rhs) -> SBBreakpoint

new_SBBreakpointLocation()
new_SBBreakpointLocation(SBBreakpointLocation rhs) -> SBBreakpointLocation

new_SBBroadcaster()
SBBroadcaster(char const * name) new_SBBroadcaster(SBBroadcaster rhs) -> SBBroadcaster

new_SBCommandInterpreter(...)
new_SBCommandInterpreter(SBCommandInterpreter rhs) -> SBCommandInterpreter

new_SBCommandReturnObject()
new_SBCommandReturnObject(SBCommandReturnObject rhs) -> SBCommandReturnObject

new_SBCommunication()
new_SBCommunication(char const * broadcaster_name) -> SBCommunication

new_SBCompileUnit()
new_SBCompileUnit(SBCompileUnit rhs) -> SBCompileUnit

new_SBData()
new_SBData(SBData rhs) -> SBData

new_SBDebugger()
new_SBDebugger(SBDebugger rhs) -> SBDebugger

new_SBDeclaration()
new_SBDeclaration(SBDeclaration rhs) -> SBDeclaration

new_SBError()
new_SBError(SBError rhs) -> SBError

new_SBEvent()
SBEvent(SBEvent rhs) __init__(self, int type, str data) -> SBEvent (make an event that contains a C string)

new_SBExpressionOptions()
new_SBExpressionOptions(SBExpressionOptions rhs) -> SBExpressionOptions

new_SBFileSpec()
SBFileSpec(SBFileSpec rhs) SBFileSpec(char const * path) new_SBFileSpec(char const * path, bool resolve) -> SBFileSpec

new_SBFileSpecList()
new_SBFileSpecList(SBFileSpecList rhs) -> SBFileSpecList

new_SBFrame()
new_SBFrame(SBFrame rhs) -> SBFrame

new_SBFunction()
new_SBFunction(SBFunction rhs) -> SBFunction

SBHostOS

new_SBHostOS()

new_SBInputReader()
new_SBInputReader(SBInputReader rhs) -> SBInputReader

new_SBInstruction()
new_SBInstruction(SBInstruction rhs) -> SBInstruction

new_SBInstructionList()
new_SBInstructionList(SBInstructionList rhs) -> SBInstructionList

new_SBLaunchInfo(...)
new_SBLaunchInfo(char const ** argv) -> SBLaunchInfo

new_SBLineEntry()
new_SBLineEntry(SBLineEntry rhs) -> SBLineEntry

new_SBListener()
SBListener(char const * name) new_SBListener(SBListener rhs) -> SBListener

new_SBModule()
SBModule(SBModule rhs) SBModule(SBModuleSpec module_spec) new_SBModule(SBProcess process, lldb::addr_t header_addr) -> SBModule

new_SBModuleSpec()
new_SBModuleSpec(SBModuleSpec rhs) -> SBModuleSpec

new_SBModuleSpecList()
new_SBModuleSpecList(SBModuleSpecList rhs) -> SBModuleSpecList

new_SBProcess()
new_SBProcess(SBProcess rhs) -> SBProcess

new_SBSection()
new_SBSection(SBSection rhs) -> SBSection

new_SBSourceManager(...)
new_SBSourceManager(SBSourceManager rhs) -> SBSourceManager

SBStream

new_SBStream()

new_SBStringList()
new_SBStringList(SBStringList rhs) -> SBStringList

new_SBSymbol()
new_SBSymbol(SBSymbol rhs) -> SBSymbol

new_SBSymbolContext()
new_SBSymbolContext(SBSymbolContext rhs) -> SBSymbolContext

new_SBSymbolContextList()
new_SBSymbolContextList(SBSymbolContextList rhs) -> SBSymbolContextList

new_SBTarget()
new_SBTarget(SBTarget rhs) -> SBTarget

new_SBThread()
new_SBThread(SBThread thread) -> SBThread

new_SBType()
new_SBType(SBType rhs) -> SBType

new_SBTypeCategory()
new_SBTypeCategory(SBTypeCategory rhs) -> SBTypeCategory

new_SBTypeFilter()
SBTypeFilter(uint32_t options) new_SBTypeFilter(SBTypeFilter rhs) -> SBTypeFilter

new_SBTypeFormat()
SBTypeFormat(lldb::Format format, uint32_t options=0) SBTypeFormat(lldb::Format format) new_SBTypeFormat(SBTypeFormat rhs) -> SBTypeFormat

SBTypeList

new_SBTypeList()

new_SBTypeMember()
new_SBTypeMember(SBTypeMember rhs) -> SBTypeMember

new_SBTypeNameSpecifier()
SBTypeNameSpecifier(char const * name, bool is_regex=False) SBTypeNameSpecifier(char const * name) SBTypeNameSpecifier(SBType type) new_SBTypeNameSpecifier(SBTypeNameSpecifier rhs) -> SBTypeNameSpecifier

new_SBTypeSummary()
new_SBTypeSummary(SBTypeSummary rhs) -> SBTypeSummary

new_SBTypeSynthetic()
new_SBTypeSynthetic(SBTypeSynthetic rhs) -> SBTypeSynthetic

new_SBValue()
new_SBValue(SBValue rhs) -> SBValue

new_SBValueList()
new_SBValueList(SBValueList rhs) -> SBValueList

new_SBWatchpoint()
new_SBWatchpoint(SBWatchpoint rhs) -> SBWatchpoint

Variables

[hide private]

LLDB_ARCH_DEFAULT = 'systemArch'

LLDB_ARCH_DEFAULT_32BIT = 'systemArch32'

LLDB_ARCH_DEFAULT_64BIT = 'systemArch64'

LLDB_DEFAULT_BREAK_SIZE = 0

LLDB_GENERIC_ERROR = 4294967295

LLDB_INVALID_ADDRESS = 18446744073709551615

LLDB_INVALID_BREAK_ID = 0

LLDB_INVALID_CPUTYPE = 4294967294

LLDB_INVALID_FRAME_ID = 4294967295

LLDB_INVALID_IMAGE_TOKEN = 4294967295

LLDB_INVALID_INDEX32 = 4294967295

LLDB_INVALID_IVAR_OFFSET = 4294967295

LLDB_INVALID_OFFSET = 18446744073709551615

LLDB_INVALID_PROCESS_ID = 0

LLDB_INVALID_REGNUM = 4294967295

LLDB_INVALID_THREAD_ID = 0

LLDB_INVALID_UID = 18446744073709551615

LLDB_INVALID_WATCH_ID = 0

LLDB_MAX_NUM_OPTION_SETS = 32

LLDB_OPT_SET_1 = 1

LLDB_OPT_SET_10 = 512

LLDB_OPT_SET_2 = 2

LLDB_OPT_SET_3 = 4

LLDB_OPT_SET_4 = 8

LLDB_OPT_SET_5 = 16

LLDB_OPT_SET_6 = 32

LLDB_OPT_SET_7 = 64

LLDB_OPT_SET_8 = 128

LLDB_OPT_SET_9 = 256

LLDB_OPT_SET_ALL = 4294967295

LLDB_REGNUM_GENERIC_ARG1 = 5

LLDB_REGNUM_GENERIC_ARG2 = 6

LLDB_REGNUM_GENERIC_ARG3 = 7

LLDB_REGNUM_GENERIC_ARG4 = 8

LLDB_REGNUM_GENERIC_ARG5 = 9

LLDB_REGNUM_GENERIC_ARG6 = 10

LLDB_REGNUM_GENERIC_ARG7 = 11

LLDB_REGNUM_GENERIC_ARG8 = 12

LLDB_REGNUM_GENERIC_FLAGS = 4

LLDB_REGNUM_GENERIC_FP = 2

LLDB_REGNUM_GENERIC_PC = 0

LLDB_REGNUM_GENERIC_RA = 3

LLDB_REGNUM_GENERIC_SP = 1

LLDB_WATCH_TYPE_READ = 1

LLDB_WATCH_TYPE_WRITE = 2

SBCommandInterpreter_eBroadcastBitAsynchronousErrorData = 16

SBCommandInterpreter_eBroadcastBitAsynchronousOutputData = 8

SBCommandInterpreter_eBroadcastBitQuitCommandReceived = 4

SBCommandInterpreter_eBroadcastBitResetPrompt = 2

SBCommandInterpreter_eBroadcastBitThreadShouldExit = 1

SBCommunication_eAllEventBits = -1

SBCommunication_eBroadcastBitDisconnected = 1

SBCommunication_eBroadcastBitPacketAvailable = 16

SBCommunication_eBroadcastBitReadThreadDidExit = 4

SBCommunication_eBroadcastBitReadThreadGotBytes = 2

SBCommunication_eBroadcastBitReadThreadShouldExit = 8

SBProcess_eBroadcastBitInterrupt = 2

SBProcess_eBroadcastBitProfileData = 16

SBProcess_eBroadcastBitSTDERR = 8

SBProcess_eBroadcastBitSTDOUT = 4

SBProcess_eBroadcastBitStateChanged = 1

SBTarget_eBroadcastBitBreakpointChanged = 1

SBTarget_eBroadcastBitModulesLoaded = 2

SBTarget_eBroadcastBitModulesUnloaded = 4

SBTarget_eBroadcastBitSymbolsLoaded = 16

SBTarget_eBroadcastBitWatchpointChanged = 8

UINT32_MAX = 4294967295

UINT64_MAX = 18446744073709551615

__package__ = None

eAccessNone = 0

eAccessPackage = 4

eAccessPrivate = 2

eAccessProtected = 3

eAccessPublic = 1

eAddressClassCode = 2

eAddressClassCodeAlternateISA = 3

eAddressClassData = 4

eAddressClassDebug = 5

eAddressClassInvalid = 0

eAddressClassRuntime = 6

eAddressClassUnknown = 1

eAllThreads = 1

eArgTypeAddress = 0

eArgTypeAddressOrExpression = 1

eArgTypeAliasName = 2

eArgTypeAliasOptions = 3

eArgTypeArchitecture = 4

eArgTypeBoolean = 5

eArgTypeBreakpointID = 6

eArgTypeBreakpointIDRange = 7

eArgTypeByteSize = 8

eArgTypeClassName = 9

eArgTypeCommandName = 10

eArgTypeCount = 11

eArgTypeDirectoryName = 12

eArgTypeDisassemblyFlavor = 13

eArgTypeEndAddress = 14

eArgTypeExprFormat = 17

eArgTypeExpression = 15

eArgTypeExpressionPath = 16

eArgTypeFilename = 18

eArgTypeFormat = 19

eArgTypeFrameIndex = 20

eArgTypeFullName = 21

eArgTypeFunctionName = 22

eArgTypeFunctionOrSymbol = 23

eArgTypeGDBFormat = 24

eArgTypeIndex = 25

eArgTypeLanguage = 26

eArgTypeLastArg = 76

eArgTypeLineNum = 27

eArgTypeLogCategory = 28

eArgTypeLogChannel = 29

eArgTypeMethod = 30

eArgTypeName = 31

eArgTypeNewPathPrefix = 32

eArgTypeNone = 71

eArgTypeNumLines = 33

eArgTypeNumberPerLine = 34

eArgTypeOffset = 35

eArgTypeOldPathPrefix = 36

eArgTypeOneLiner = 37

eArgTypePid = 38

eArgTypePlatform = 72

eArgTypePlugin = 39

eArgTypeProcessName = 40

eArgTypePythonClass = 41

eArgTypePythonFunction = 42

eArgTypePythonScript = 43

eArgTypeQueueName = 44

eArgTypeRegisterName = 45

eArgTypeRegularExpression = 46

eArgTypeRunArgs = 47

eArgTypeRunMode = 48

eArgTypeScriptLang = 50

eArgTypeScriptedCommandSynchronicity = 49

eArgTypeSearchWord = 51

eArgTypeSelector = 52

eArgTypeSettingIndex = 53

eArgTypeSettingKey = 54

eArgTypeSettingPrefix = 55

eArgTypeSettingVariableName = 56

eArgTypeShlibName = 57

eArgTypeSortOrder = 59

eArgTypeSourceFile = 58

eArgTypeStartAddress = 60

eArgTypeSummaryString = 61

eArgTypeSymbol = 62

eArgTypeThreadID = 63

eArgTypeThreadIndex = 64

eArgTypeThreadName = 65

eArgTypeUnixSignal = 67

eArgTypeUnsignedInteger = 66

eArgTypeValue = 69

eArgTypeVarName = 68

eArgTypeWatchType = 75

eArgTypeWatchpointID = 73

eArgTypeWatchpointIDRange = 74

eArgTypeWidth = 70

eBasicTypeBool = 20

eBasicTypeChar = 2

eBasicTypeChar16 = 8

eBasicTypeChar32 = 9

eBasicTypeDouble = 23

eBasicTypeDoubleComplex = 26

eBasicTypeFloat = 22

eBasicTypeFloatComplex = 25

eBasicTypeHalf = 21

eBasicTypeInt = 12

eBasicTypeInt128 = 18

eBasicTypeInvalid = 0

eBasicTypeLong = 14

eBasicTypeLongDouble = 24

eBasicTypeLongDoubleComplex = 27

eBasicTypeLongLong = 16

eBasicTypeNullPtr = 31

eBasicTypeObjCClass = 29

eBasicTypeObjCID = 28

eBasicTypeObjCSel = 30

eBasicTypeOther = 32

eBasicTypeShort = 10

eBasicTypeSignedChar = 3

eBasicTypeSignedWChar = 6

eBasicTypeUnsignedChar = 4

eBasicTypeUnsignedInt = 13

eBasicTypeUnsignedInt128 = 19

eBasicTypeUnsignedLong = 15

eBasicTypeUnsignedLongLong = 17

eBasicTypeUnsignedShort = 11

eBasicTypeUnsignedWChar = 7

eBasicTypeVoid = 1

eBasicTypeWChar = 5

eBreakpointEventTypeAdded = 2

eBreakpointEventTypeCommandChanged = 256

eBreakpointEventTypeConditionChanged = 512

eBreakpointEventTypeDisabled = 128

eBreakpointEventTypeEnabled = 64

eBreakpointEventTypeIgnoreChanged = 1024

eBreakpointEventTypeInvalidType = 1

eBreakpointEventTypeLocationsAdded = 8

eBreakpointEventTypeLocationsRemoved = 16

eBreakpointEventTypeLocationsResolved = 32

eBreakpointEventTypeRemoved = 4

eBreakpointEventTypeThreadChanged = 2048

eByteOrderBig = 1

eByteOrderInvalid = 0

eByteOrderLittle = 4

eByteOrderPDP = 2

eConnectionStatusEndOfFile = 1

eConnectionStatusError = 2

eConnectionStatusLostConnection = 5

eConnectionStatusNoConnection = 4

eConnectionStatusSuccess = 0

eConnectionStatusTimedOut = 3

eDescriptionLevelBrief = 0

eDescriptionLevelFull = 1

eDescriptionLevelInitial = 3

eDescriptionLevelVerbose = 2

eDynamicCanRunTarget = 1

eDynamicDontRunTarget = 2

eEmulateInstructionOptionAutoAdvancePC = 1

eEmulateInstructionOptionIgnoreConditions = 2

eEmulateInstructionOptionNone = 0

eEncodingIEEE754 = 3

eEncodingInvalid = 0

eEncodingSint = 2

eEncodingUint = 1

eEncodingVector = 4

eErrorTypeGeneric = 1

eErrorTypeInvalid = 0

eErrorTypeMachKernel = 2

eErrorTypePOSIX = 3

eFormatAddressInfo = 34

eFormatBinary = 2

eFormatBoolean = 1

eFormatBytes = 3

eFormatBytesWithASCII = 4

eFormatCString = 8

eFormatChar = 5

eFormatCharArray = 33

eFormatCharPrintable = 6

eFormatComplex = 7

eFormatComplexFloat = 7

eFormatComplexInteger = 32

eFormatDecimal = 9

eFormatDefault = 0

eFormatEnum = 10

eFormatFloat = 13

eFormatHex = 11

eFormatHexFloat = 35

eFormatHexUppercase = 12

eFormatInstruction = 36

eFormatInvalid = 0

eFormatOSType = 15

eFormatOctal = 14

eFormatPointer = 19

eFormatUnicode16 = 16

eFormatUnicode32 = 17

eFormatUnsigned = 18

eFormatVectorOfChar = 20

eFormatVectorOfFloat32 = 29

eFormatVectorOfFloat64 = 30

eFormatVectorOfSInt16 = 23

eFormatVectorOfSInt32 = 25

eFormatVectorOfSInt64 = 27

eFormatVectorOfSInt8 = 21

eFormatVectorOfUInt128 = 31

eFormatVectorOfUInt16 = 24

eFormatVectorOfUInt32 = 26

eFormatVectorOfUInt64 = 28

eFormatVectorOfUInt8 = 22

eFormatVoid = 37

eFrameCompareEqual = 2

eFrameCompareInvalid = 0

eFrameCompareOlder = 4

eFrameCompareUnknown = 1

eFrameCompareYounger = 3

eFunctionNameTypeAny = 2

eFunctionNameTypeAuto = 2

eFunctionNameTypeBase = 8

eFunctionNameTypeFull = 4

eFunctionNameTypeMethod = 16

eFunctionNameTypeNone = 0

eFunctionNameTypeSelector = 32

eInputReaderActivate = 0

eInputReaderAsynchronousOutputWritten = 1

eInputReaderDeactivate = 3

eInputReaderDone = 7

eInputReaderEndOfFile = 6

eInputReaderGotToken = 4

eInputReaderGranularityAll = 4

eInputReaderGranularityByte = 1

eInputReaderGranularityInvalid = 0

eInputReaderGranularityLine = 3

eInputReaderGranularityWord = 2

eInputReaderInterrupt = 5

eInputReaderReactivate = 2

eLanguageTypeAda83 = 3

eLanguageTypeAda95 = 13

eLanguageTypeC = 2

eLanguageTypeC89 = 1

eLanguageTypeC99 = 12

eLanguageTypeC_plus_plus = 4

eLanguageTypeCobol74 = 5

eLanguageTypeCobol85 = 6

eLanguageTypeD = 19

eLanguageTypeFortran77 = 7

eLanguageTypeFortran90 = 8

eLanguageTypeFortran95 = 14

eLanguageTypeJava = 11

eLanguageTypeModula2 = 10

eLanguageTypeObjC = 16

eLanguageTypeObjC_plus_plus = 17

eLanguageTypePLI = 15

eLanguageTypePascal83 = 9

eLanguageTypePython = 20

eLanguageTypeUPC = 18

eLanguageTypeUnknown = 0

eLaunchFlagDebug = 2

eLaunchFlagDisableASLR = 8

eLaunchFlagDisableSTDIO = 16

eLaunchFlagExec = 1

eLaunchFlagLaunchInSeparateProcessGroup = 128

eLaunchFlagLaunchInShell = 64

eLaunchFlagLaunchInTTY = 32

eLaunchFlagNone = 0

eLaunchFlagStopAtEntry = 4

eNoDynamicValues = 0

eNumLanguageTypes = 21

eOnlyDuringStepping = 2

eOnlyThisThread = 0

ePermissionsExecutable = 4

ePermissionsReadable = 2

ePermissionsWritable = 1

eRegisterKindDWARF = 1

eRegisterKindGCC = 0

eRegisterKindGDB = 3

eRegisterKindGeneric = 2

eRegisterKindLLDB = 4

eReturnStatusFailed = 6

eReturnStatusInvalid = 0

eReturnStatusQuit = 7

eReturnStatusStarted = 5

eReturnStatusSuccessContinuingNoResult = 3

eReturnStatusSuccessContinuingResult = 4

eReturnStatusSuccessFinishNoResult = 1

eReturnStatusSuccessFinishResult = 2

eScriptLanguageDefault = 1

eScriptLanguageNone = 0

eScriptLanguagePython = 1

eSectionTypeCode = 1

eSectionTypeContainer = 2

eSectionTypeDWARFAppleNames = 26

eSectionTypeDWARFAppleNamespaces = 28

eSectionTypeDWARFAppleObjC = 29

eSectionTypeDWARFAppleTypes = 27

eSectionTypeDWARFDebugAbbrev = 15

eSectionTypeDWARFDebugAranges = 16

eSectionTypeDWARFDebugFrame = 17

eSectionTypeDWARFDebugInfo = 18

eSectionTypeDWARFDebugLine = 19

eSectionTypeDWARFDebugLoc = 20

eSectionTypeDWARFDebugMacInfo = 21

eSectionTypeDWARFDebugPubNames = 22

eSectionTypeDWARFDebugPubTypes = 23

eSectionTypeDWARFDebugRanges = 24

eSectionTypeDWARFDebugStr = 25

eSectionTypeData = 3

eSectionTypeData16 = 9

eSectionTypeData4 = 7

eSectionTypeData8 = 8

eSectionTypeDataCString = 4

eSectionTypeDataCStringPointers = 5

eSectionTypeDataObjCCFStrings = 14

eSectionTypeDataObjCMessageRefs = 13

eSectionTypeDataPointers = 10

eSectionTypeDataSymbolAddress = 6

eSectionTypeDebug = 11

eSectionTypeEHFrame = 34

eSectionTypeELFDynamicLinkInfo = 33

eSectionTypeELFDynamicSymbols = 31

eSectionTypeELFRelocationEntries = 32

eSectionTypeELFSymbolTable = 30

eSectionTypeInvalid = 0

eSectionTypeOther = 35

eSectionTypeZeroFill = 12

eStateAttaching = 3

eStateConnected = 2

eStateCrashed = 8

eStateDetached = 9

eStateExited = 10

eStateInvalid = 0

eStateLaunching = 4

eStateRunning = 6

eStateStepping = 7

eStateStopped = 5

eStateSuspended = 11

eStateUnloaded = 1

eStopReasonBreakpoint = 3

eStopReasonException = 6

eStopReasonExec = 7

eStopReasonInvalid = 0

eStopReasonNone = 1

eStopReasonPlanComplete = 8

eStopReasonSignal = 5

eStopReasonThreadExiting = 9

eStopReasonTrace = 2

eStopReasonWatchpoint = 4

eSymbolContextBlock = 16

eSymbolContextCompUnit = 4

eSymbolContextEverything = 127

eSymbolContextFunction = 8

eSymbolContextLineEntry = 32

eSymbolContextModule = 2

eSymbolContextSymbol = 64

eSymbolContextTarget = 1

eSymbolTypeAbsolute = 1

eSymbolTypeAdditional = 21

eSymbolTypeAny = 0

eSymbolTypeBlock = 12

eSymbolTypeCode = 2

eSymbolTypeCommonBlock = 11

eSymbolTypeCompiler = 22

eSymbolTypeData = 4

eSymbolTypeException = 7

eSymbolTypeHeaderFile = 9

eSymbolTypeInstrumentation = 23

eSymbolTypeInvalid = 0

eSymbolTypeLineEntry = 17

eSymbolTypeLineHeader = 18

eSymbolTypeLocal = 13

eSymbolTypeObjCClass = 25

eSymbolTypeObjCIVar = 27

eSymbolTypeObjCMetaClass = 26

eSymbolTypeObjectFile = 10

eSymbolTypeParam = 14

eSymbolTypeResolver = 3

eSymbolTypeRuntime = 6

eSymbolTypeScopeBegin = 19

eSymbolTypeScopeEnd = 20

eSymbolTypeSourceFile = 8

eSymbolTypeTrampoline = 5

eSymbolTypeUndefined = 24

eSymbolTypeVariable = 15

eSymbolTypeVariableType = 16

eTemplateArgumentKindDeclaration = 2

eTemplateArgumentKindExpression = 6

eTemplateArgumentKindIntegral = 3

eTemplateArgumentKindNull = 0

eTemplateArgumentKindPack = 7

eTemplateArgumentKindTemplate = 4

eTemplateArgumentKindTemplateExpansion = 5

eTemplateArgumentKindType = 1

eTypeClassAny = -1

eTypeClassArray = 1

eTypeClassBlockPointer = 2

eTypeClassBuiltin = 4

eTypeClassClass = 8

eTypeClassComplexFloat = 16

eTypeClassComplexInteger = 32

eTypeClassEnumeration = 64

eTypeClassFunction = 128

eTypeClassInvalid = 0

eTypeClassMemberPointer = 256

eTypeClassObjCInterface = 1024

eTypeClassObjCObject = 512

eTypeClassObjCObjectPointer = 2048

eTypeClassOther = -2147483648

eTypeClassPointer = 4096

eTypeClassReference = 8192

eTypeClassStruct = 16384

eTypeClassTypedef = 32768

eTypeClassUnion = 65536

eTypeClassVector = 131072

eTypeOptionCascade = 1

eTypeOptionHideChildren = 8

eTypeOptionHideNames = 64

eTypeOptionHideValue = 16

eTypeOptionNone = 0

eTypeOptionShowOneLiner = 32

eTypeOptionSkipPointers = 2

eTypeOptionSkipReferences = 4

eValueTypeConstResult = 7

eValueTypeInvalid = 0

eValueTypeRegister = 5

eValueTypeRegisterSet = 6

eValueTypeVariableArgument = 3

eValueTypeVariableGlobal = 1

eValueTypeVariableLocal = 4

eValueTypeVariableStatic = 2

eWatchpointEventTypeAdded = 2

eWatchpointEventTypeCommandChanged = 256

eWatchpointEventTypeConditionChanged = 512

eWatchpointEventTypeDisabled = 128

eWatchpointEventTypeEnabled = 64

eWatchpointEventTypeIgnoreChanged = 1024

eWatchpointEventTypeInvalidType = 1

eWatchpointEventTypeRemoved = 4

eWatchpointEventTypeThreadChanged = 2048

eWatchpointEventTypeTypeChanged = 4096

kNumDescriptionLevels = 4

kNumFormats = 38

kNumRegisterKinds = 5

Function Details

[hide private]

SBAddress_GetModule(...)

SBAddress_GetModule(SBAddress self) -> SBModule

//------------------------------------------------------------------ /// GetModule() and the following grab individual objects for a given address and /// are less efficient if you want more than one symbol related objects. /// Use one of the following when you want multiple debug symbol related /// objects for an address: /// lldb::SBSymbolContext SBAddress::GetSymbolContext (uint32_t resolve_scope); /// lldb::SBSymbolContext SBTarget::ResolveSymbolContextForAddress (const SBAddress &addr, uint32_t resolve_scope); /// One or more bits from the SymbolContextItem enumerations can be logically /// OR'ed together to more efficiently retrieve multiple symbol objects. //------------------------------------------------------------------

SBAddress_GetSymbolContext(...)

SBAddress_GetSymbolContext(SBAddress self, uint32_t resolve_scope) -> SBSymbolContext

//------------------------------------------------------------------ /// GetSymbolContext() and the following can lookup symbol information for a given address. /// An address might refer to code or data from an existing module, or it /// might refer to something on the stack or heap. The following functions /// will only return valid values if the address has been resolved to a code /// or data address using 'void SBAddress::SetLoadAddress(...)' or /// 'lldb::SBAddress SBTarget::ResolveLoadAddress (...)'. //------------------------------------------------------------------

SBBlock_GetContainingInlinedBlock(...)

SBBlock_GetContainingInlinedBlock(SBBlock self) -> SBBlock

Get the inlined block that is or contains this block.

SBBlock_GetFirstChild(...)

SBBlock_GetFirstChild(SBBlock self) -> SBBlock

Get the first child block.

SBBlock_GetInlinedCallSiteColumn(...)

SBBlock_GetInlinedCallSiteColumn(SBBlock self) -> uint32_t

Get the call site column if this block represents an inlined function; otherwise, return 0.

SBBlock_GetInlinedCallSiteFile(...)

SBBlock_GetInlinedCallSiteFile(SBBlock self) -> SBFileSpec

Get the call site file if this block represents an inlined function; otherwise, return an invalid file spec.

SBBlock_GetInlinedCallSiteLine(...)

SBBlock_GetInlinedCallSiteLine(SBBlock self) -> uint32_t

Get the call site line if this block represents an inlined function; otherwise, return 0.

SBBlock_GetInlinedName(...)

SBBlock_GetInlinedName(SBBlock self) -> char const *

Get the function name if this block represents an inlined function; otherwise, return None.

SBBlock_GetParent(...)

SBBlock_GetParent(SBBlock self) -> SBBlock

Get the parent block.

SBBlock_GetSibling(...)

SBBlock_GetSibling(SBBlock self) -> SBBlock

Get the sibling block for this block.

SBBlock_IsInlined(...)

SBBlock_IsInlined(SBBlock self) -> bool

Does this block represent an inlined function?

SBBreakpointLocation_GetCondition(...)

SBBreakpointLocation_GetCondition(SBBreakpointLocation self) -> char const *

//------------------------------------------------------------------ /// Get the condition expression for the breakpoint location. //------------------------------------------------------------------

SBBreakpointLocation_SetCondition(...)

SBBreakpointLocation_SetCondition(SBBreakpointLocation self, char const * condition)

//-------------------------------------------------------------------------- /// The breakpoint location stops only if the condition expression evaluates /// to true. //--------------------------------------------------------------------------

SBBreakpoint_GetCondition(...)

SBBreakpoint_GetCondition(SBBreakpoint self) -> char const *

//------------------------------------------------------------------ /// Get the condition expression for the breakpoint. //------------------------------------------------------------------

SBBreakpoint_SetCondition(...)

SBBreakpoint_SetCondition(SBBreakpoint self, char const * condition)

//-------------------------------------------------------------------------- /// The breakpoint stops only if the condition expression evaluates to true. //--------------------------------------------------------------------------

SBCommandInterpreter_HandleCompletion(...)


SBCommandInterpreter_HandleCompletion(SBCommandInterpreter self, char const * current_line, uint32_t cursor_pos, int match_start_point, 
    int max_return_elements, SBStringList matches) -> int

SBCompileUnit_FindLineEntryIndex(...)


FindLineEntryIndex(uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec) -> uint32_t
SBCompileUnit_FindLineEntryIndex(SBCompileUnit self, uint32_t start_idx, uint32_t line, SBFileSpec inline_file_spec, 
    bool exact) -> uint32_t

SBCompileUnit_GetTypes(...)

GetTypes(uint32_t type_mask=eTypeClassAny) -> SBTypeList SBCompileUnit_GetTypes(SBCompileUnit self) -> SBTypeList

//------------------------------------------------------------------ /// Get all types matching type_mask from debug info in this /// compile unit. /// /// @param[in] type_mask /// A bitfield that consists of one or more bits logically OR'ed /// together from the lldb::TypeClass enumeration. This allows /// you to request only structure types, or only class, struct /// and union types. Passing in lldb::eTypeClassAny will return /// all types found in the debug information for this compile /// unit. /// /// @return /// A list of types in this compile unit that match type_mask //------------------------------------------------------------------

SBDebugger_CreateTarget(...)


CreateTarget(char const * filename, char const * target_triple, char const * platform_name, bool add_dependent_modules, 
    SBError sb_error) -> SBTarget
SBDebugger_CreateTarget(SBDebugger self, char const * filename) -> SBTarget

SBDebugger_DeleteTarget(...)

SBDebugger_DeleteTarget(SBDebugger self, SBTarget target) -> bool

Return true if target is deleted from the target list of the debugger.

SBExpressionOptions_SetCoerceResultToId(...)

SetCoerceResultToId(bool coerce=True) SBExpressionOptions_SetCoerceResultToId(SBExpressionOptions self)

Sets whether to coerce the expression result to ObjC id type after evaluation.

SBExpressionOptions_SetFetchDynamicValue(...)

SetFetchDynamicValue(lldb::DynamicValueType dynamic=eDynamicCanRunTarget) SBExpressionOptions_SetFetchDynamicValue(SBExpressionOptions self)

Sets whether to cast the expression result to its dynamic type.

SBExpressionOptions_SetTimeoutInMicroSeconds(...)

SetTimeoutInMicroSeconds(uint32_t timeout=0) SBExpressionOptions_SetTimeoutInMicroSeconds(SBExpressionOptions self)

Sets the timeout in microseconds to run the expression for. If try all threads is set to true and the expression doesn't complete within the specified timeout, all threads will be resumed for the same timeout to see if the expresson will finish.

SBExpressionOptions_SetTryAllThreads(...)

SetTryAllThreads(bool run_others=True) SBExpressionOptions_SetTryAllThreads(SBExpressionOptions self)

Sets whether to run all threads if the expression does not complete on one thread.

SBExpressionOptions_SetUnwindOnError(...)

SetUnwindOnError(bool unwind=True) SBExpressionOptions_SetUnwindOnError(SBExpressionOptions self)

Sets whether to unwind the expression stack on error.

SBFrame_EvaluateExpression(...)

EvaluateExpression(char const * expr) -> SBValue EvaluateExpression(char const * expr, lldb::DynamicValueType use_dynamic) -> SBValue EvaluateExpression(char const * expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error) -> SBValue SBFrame_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.

SBFrame_FindValue(...)

FindValue(char const * name, lldb::ValueType value_type) -> SBValue SBFrame_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.

SBFrame_FindVariable(...)

FindVariable(char const * var_name) -> SBValue SBFrame_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.

SBFrame_GetBlock(...)

SBFrame_GetBlock(SBFrame self) -> SBBlock

/// Gets the deepest block that contains the frame PC. /// /// See also GetFrameBlock().

SBFrame_GetFrameBlock(...)

SBFrame_GetFrameBlock(SBFrame self) -> SBBlock

/// 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.

SBFrame_GetFunctionName(...)

SBFrame_GetFunctionName(SBFrame self) -> char 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 appriopriate 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().

SBFrame_GetValueForVariablePath(...)

GetValueForVariablePath(char const * var_path) -> SBValue SBFrame_GetValueForVariablePath(SBFrame self, char const * var_path, lldb::DynamicValueType use_dynamic) -> SBValue

/// 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.

SBFrame_GetVariables(...)

GetVariables(bool arguments, bool locals, bool statics, bool in_scope_only) -> SBValueList SBFrame_GetVariables(SBFrame self, bool arguments, bool locals, bool statics, bool in_scope_only, lldb::DynamicValueType use_dynamic) -> SBValueList

/// The version that doesn't supply a 'use_dynamic' value will use the /// target's default.

SBFrame_IsInlined(...)

SBFrame_IsInlined(SBFrame self) -> bool

/// Return true if this frame represents an inlined function. /// /// See also GetFunctionName().

SBInputReader_Initialize(...)


SBInputReader_Initialize(SBInputReader self, SBDebugger debugger, lldb::SBInputReader::Callback callback, 
    lldb::InputReaderGranularity granularity, char const * end_token, char const * prompt, 
    bool echo) -> SBError

SBListener_WaitForEventForBroadcasterWithType(...)


SBListener_WaitForEventForBroadcasterWithType(SBListener self, uint32_t num_seconds, SBBroadcaster broadcaster, uint32_t event_type_mask, 
    SBEvent sb_event) -> bool

SBModule_FindFirstGlobalVariable(...)

SBModule_FindFirstGlobalVariable(SBModule self, SBTarget target, char const * name) -> SBValue

//------------------------------------------------------------------ /// Find the first global (or static) variable by name. /// /// @param[in] target /// A valid SBTarget instance representing the debuggee. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @return /// An SBValue that gets filled in with the found variable (if any). //------------------------------------------------------------------

SBModule_FindFunctions(...)

FindFunctions(char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList SBModule_FindFunctions(SBModule self, char const * name) -> SBSymbolContextList

//------------------------------------------------------------------ /// Find functions by name. /// /// @param[in] name /// The name of the function we are looking for. /// /// @param[in] name_type_mask /// A logical OR of one or more FunctionNameType enum bits that /// indicate what kind of names should be used when doing the /// lookup. Bits include fully qualified names, base names, /// C++ methods, or ObjC selectors. /// See FunctionNameType for more details. /// /// @return /// A symbol context list that gets filled in with all of the /// matches. //------------------------------------------------------------------

SBModule_FindGlobalVariables(...)

SBModule_FindGlobalVariables(SBModule self, SBTarget target, char const * name, uint32_t max_matches) -> SBValueList

//------------------------------------------------------------------ /// Find global and static variables by name. /// /// @param[in] target /// A valid SBTarget instance representing the debuggee. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @param[in] max_matches /// Allow the number of matches to be limited to max_matches. /// /// @return /// A list of matched variables in an SBValueList. //------------------------------------------------------------------

SBModule_GetFileSpec(...)

SBModule_GetFileSpec(SBModule self) -> SBFileSpec

//------------------------------------------------------------------ /// Get const accessor for the module file specification. /// /// This function returns the file for the module on the host system /// that is running LLDB. This can differ from the path on the /// platform since we might be doing remote debugging. /// /// @return /// A const reference to the file specification object. //------------------------------------------------------------------

SBModule_GetPlatformFileSpec(...)

SBModule_GetPlatformFileSpec(SBModule self) -> SBFileSpec

//------------------------------------------------------------------ /// Get accessor for the module platform file specification. /// /// Platform file refers to the path of the module as it is known on /// the remote system on which it is being debugged. For local /// debugging this is always the same as Module::GetFileSpec(). But /// remote debugging might mention a file '/usr/lib/liba.dylib' /// which might be locally downloaded and cached. In this case the /// platform file could be something like: /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib' /// The file could also be cached in a local developer kit directory. /// /// @return /// A const reference to the file specification object. //------------------------------------------------------------------

SBModule_GetTypes(...)

GetTypes(uint32_t type_mask=eTypeClassAny) -> SBTypeList SBModule_GetTypes(SBModule self) -> SBTypeList

//------------------------------------------------------------------ /// Get all types matching type_mask from debug info in this /// module. /// /// @param[in] type_mask /// A bitfield that consists of one or more bits logically OR'ed /// together from the lldb::TypeClass enumeration. This allows /// you to request only structure types, or only class, struct /// and union types. Passing in lldb::eTypeClassAny will return /// all types found in the debug information for this module. /// /// @return /// A list of types in this module that match type_mask //------------------------------------------------------------------

SBModule_GetUUIDString(...)

SBModule_GetUUIDString(SBModule self) -> char const *

Returns the UUID of the module as a Python string.

SBProcess_Destroy(...)

SBProcess_Destroy(SBProcess self) -> SBError

Kills the process and shuts down all threads that were spawned to track and monitor process.

SBProcess_GetSTDERR(...)

Reads data from the current process's stderr stream. API client specifies the size of the buffer to read data into. It returns the byte buffer in a Python string.

SBProcess_GetSTDOUT(...)

Reads data from the current process's stdout stream. API client specifies the size of the buffer to read data into. It returns the byte buffer in a Python string.

SBProcess_GetStopID(...)

GetStopID(bool include_expression_stops=False) -> uint32_t SBProcess_GetStopID(SBProcess self) -> uint32_t

Returns a stop id that will increase every time the process executes. If include_expression_stops is true, then stops caused by expression evaluation will cause the returned value to increase, otherwise the counter returned will only increase when execution is continued explicitly by the user. Note, the value will always increase, but may increase by more than one per stop.

SBProcess_GetThreadAtIndex(...)

Returns the INDEX'th thread from the list of current threads. The index of a thread is only valid for the current stop. For a persistent thread identifier use either the thread ID or the IndexID. See help on SBThread for more details.

SBProcess_GetUniqueID(...)

Returns an integer ID that is guaranteed to be unique across all process instances. This is not the process ID, just a unique integer for comparison and caching purposes.

SBProcess_PutSTDIN(...)

Writes data into the current process's stdin. API client specifies a Python string as the only argument.

SBProcess_ReadCStringFromMemory(...)


Reads a NULL terminated C string from the current process's address space.
It returns a python string of the exact length, or truncates the string if
the maximum character limit is reached. Example:

# Read a C string of at most 256 bytes from address '0x1000' 
error = lldb.SBError()
cstring = process.ReadCStringFromMemory(0x1000, 256, error)
if error.Success():
    print 'cstring: ', cstring
else
    print 'error: ', error

SBProcess_ReadMemory(...)

Reads memory from the current process's address space and removes any traps that may have been inserted into the memory. It returns the byte buffer in a Python string. Example:

# Read 4 bytes from address 'addr' and assume error.Success() is True. content = process.ReadMemory(addr, 4, error) # Use 'ascii' encoding as each byte of 'content' is within [0..255]. new_bytes = bytearray(content, 'ascii')

SBProcess_ReadPointerFromMemory(...)


Reads a pointer from memory from an address and returns the value. Example:

# Read a pointer from address 0x1000
error = lldb.SBError()
ptr = ReadPointerFromMemory(0x1000, error)
if error.Success():
    print 'pointer: 0x%x' % ptr
else
    print 'error: ', error

SBProcess_ReadUnsignedFromMemory(...)


Reads an unsigned integer from memory given a byte size and an address. 
Returns the unsigned integer that was read. Example:

# Read a 4 byte unsigned integer from address 0x1000
error = lldb.SBError()
uint = ReadUnsignedFromMemory(0x1000, 4, error)
if error.Success():
    print 'integer: %u' % uint
else
    print 'error: ', error

SBProcess_RemoteAttachToProcessWithID(...)

SBProcess_RemoteAttachToProcessWithID(SBProcess self, lldb::pid_t pid, SBError error) -> bool

//------------------------------------------------------------------ /// Remote connection related functions. These will fail if the /// process is not in eStateConnected. They are intended for use /// when connecting to an externally managed debugserver instance. //------------------------------------------------------------------

SBProcess_RemoteLaunch(...)


SBProcess_RemoteLaunch(SBProcess self, char const ** argv, char const ** envp, char const * stdin_path, 
    char const * stdout_path, char const * stderr_path, char const * working_directory, 
    uint32_t launch_flags, bool stop_at_entry, SBError error) -> bool

See SBTarget.Launch for argument description and usage.

SBProcess_Signal(...)

SBProcess_Signal(SBProcess self, int signal) -> SBError

Sends the process a unix signal.

SBProcess_WriteMemory(...)


Writes memory to the current process's address space and maintains any
traps that might be present due to software breakpoints. Example:

# Create a Python string from the byte array.
new_value = str(bytes)
result = process.WriteMemory(addr, new_value, error)
if not error.Success() or result != len(bytes):
    print 'SBProcess.WriteMemory() failed!'

SBSourceManager_DisplaySourceLinesWithLineNumbers(...)


SBSourceManager_DisplaySourceLinesWithLineNumbers(SBSourceManager self, SBFileSpec file, uint32_t line, uint32_t context_before, uint32_t context_after, 
    char const * current_line_cstr, SBStream s) -> size_t

SBStream_Clear(...)

SBStream_Clear(SBStream self)

//-------------------------------------------------------------------------- /// If the stream is redirected to a file, forget about the file and if /// ownership of the file was transfered to this object, close the file. /// If the stream is backed by a local cache, clear this cache. //--------------------------------------------------------------------------

SBStream_GetData(...)

SBStream_GetData(SBStream self) -> char const *

//-------------------------------------------------------------------------- /// If this stream is not redirected to a file, it will maintain a local /// cache for the stream data which can be accessed using this accessor. //--------------------------------------------------------------------------

SBStream_GetSize(...)

SBStream_GetSize(SBStream self) -> size_t

//-------------------------------------------------------------------------- /// If this stream is not redirected to a file, it will maintain a local /// cache for the stream output whose length can be accessed using this /// accessor. //--------------------------------------------------------------------------

SBTarget_AttachToProcessWithID(...)

SBTarget_AttachToProcessWithID(SBTarget self, SBListener listener, lldb::pid_t pid, SBError error) -> SBProcess

//------------------------------------------------------------------ /// Attach to process with pid. /// /// @param[in] listener /// An optional listener that will receive all process events. /// If listener is valid then listener will listen to all /// process events. If not valid, then this target's debugger /// (SBTarget::GetDebugger()) will listen to all process events. /// /// @param[in] pid /// The process ID to attach to. /// /// @param[out] /// An error explaining what went wrong if attach fails. /// /// @return /// A process object for the attached process. //------------------------------------------------------------------

SBTarget_AttachToProcessWithName(...)

SBTarget_AttachToProcessWithName(SBTarget self, SBListener listener, char const * name, bool wait_for, SBError error) -> SBProcess

//------------------------------------------------------------------ /// Attach to process with name. /// /// @param[in] listener /// An optional listener that will receive all process events. /// If listener is valid then listener will listen to all /// process events. If not valid, then this target's debugger /// (SBTarget::GetDebugger()) will listen to all process events. /// /// @param[in] name /// Basename of process to attach to. /// /// @param[in] wait_for /// If true wait for a new instance of 'name' to be launched. /// /// @param[out] /// An error explaining what went wrong if attach fails. /// /// @return /// A process object for the attached process. //------------------------------------------------------------------

SBTarget_BreakpointCreateByName(...)


BreakpointCreateByName(char const * symbol_name, char const * module_name=None) -> SBBreakpoint
BreakpointCreateByName(char const * symbol_name) -> SBBreakpoint
SBTarget_BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t func_name_type, SBFileSpecList module_list, 
    SBFileSpecList comp_unit_list) -> SBBreakpoint

SBTarget_BreakpointCreateByNames(...)


SBTarget_BreakpointCreateByNames(SBTarget self, char const *[] symbol_name, uint32_t num_names, uint32_t name_type_mask, 
    SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint

SBTarget_ConnectRemote(...)

SBTarget_ConnectRemote(SBTarget self, SBListener listener, char const * url, char const * plugin_name, SBError error) -> SBProcess

//------------------------------------------------------------------ /// Connect to a remote debug server with url. /// /// @param[in] listener /// An optional listener that will receive all process events. /// If listener is valid then listener will listen to all /// process events. If not valid, then this target's debugger /// (SBTarget::GetDebugger()) will listen to all process events. /// /// @param[in] url /// The url to connect to, e.g., 'connect://localhost:12345'. /// /// @param[in] plugin_name /// The plugin name to be used; can be NULL. /// /// @param[out] /// An error explaining what went wrong if the connect fails. /// /// @return /// A process object for the connected process. //------------------------------------------------------------------

SBTarget_FindFirstGlobalVariable(...)

SBTarget_FindFirstGlobalVariable(SBTarget self, char const * name) -> SBValue

//------------------------------------------------------------------ /// Find the first global (or static) variable by name. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @return /// An SBValue that gets filled in with the found variable (if any). //------------------------------------------------------------------

SBTarget_FindFunctions(...)

FindFunctions(char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList SBTarget_FindFunctions(SBTarget self, char const * name) -> SBSymbolContextList

//------------------------------------------------------------------ /// Find functions by name. /// /// @param[in] name /// The name of the function we are looking for. /// /// @param[in] name_type_mask /// A logical OR of one or more FunctionNameType enum bits that /// indicate what kind of names should be used when doing the /// lookup. Bits include fully qualified names, base names, /// C++ methods, or ObjC selectors. /// See FunctionNameType for more details. /// /// @return /// A lldb::SBSymbolContextList that gets filled in with all of /// the symbol contexts for all the matches. //------------------------------------------------------------------

SBTarget_FindGlobalVariables(...)

SBTarget_FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches) -> SBValueList

//------------------------------------------------------------------ /// Find global and static variables by name. /// /// @param[in] name /// The name of the global or static variable we are looking /// for. /// /// @param[in] max_matches /// Allow the number of matches to be limited to max_matches. /// /// @return /// A list of matched variables in an SBValueList. //------------------------------------------------------------------

SBTarget_Launch(...)


Launch(SBListener listener, char const ** argv, char const ** envp, char const * stdin_path, 
    char const * stdout_path, char const * stderr_path, char const * working_directory, 
    uint32_t launch_flags, bool stop_at_entry, SBError error) -> SBProcess
SBTarget_Launch(SBTarget self, SBLaunchInfo launch_info, SBError error) -> SBProcess

//------------------------------------------------------------------
/// Launch a new process.
///
/// Launch a new process by spawning a new process using the
/// target object's executable module's file as the file to launch.
/// Arguments are given in  argv, and the environment variables
/// are in  envp. Standard input and output files can be
/// optionally re-directed to  stdin_path,  stdout_path, and
///  stderr_path.
///
/// @param[in] listener
///     An optional listener that will receive all process events.
///     If  listener is valid then  listener will listen to all
///     process events. If not valid, then this target's debugger
///     (SBTarget::GetDebugger()) will listen to all process events. 
///
/// @param[in] argv
///     The argument array.
///
/// @param[in] envp
///     The environment array.
///
/// @param[in] launch_flags
///     Flags to modify the launch (@see lldb::LaunchFlags)
///
/// @param[in] stdin_path
///     The path to use when re-directing the STDIN of the new
///     process. If all stdXX_path arguments are NULL, a pseudo
///     terminal will be used.
///
/// @param[in] stdout_path
///     The path to use when re-directing the STDOUT of the new
///     process. If all stdXX_path arguments are NULL, a pseudo
///     terminal will be used.
///
/// @param[in] stderr_path
///     The path to use when re-directing the STDERR of the new
///     process. If all stdXX_path arguments are NULL, a pseudo
///     terminal will be used.
///
/// @param[in] working_directory
///     The working directory to have the child process run in
///
/// @param[in] launch_flags
///     Some launch options specified by logical OR'ing 
///     lldb::LaunchFlags enumeration values together.
///
/// @param[in] stop_at_endtry
///     If false do not stop the inferior at the entry point.
///
/// @param[out]
///     An error object. Contains the reason if there is some failure.
///
/// @return
///      A process object for the newly created process.
//------------------------------------------------------------------

For example,

    process = target.Launch(self.dbg.GetListener(), None, None,
                            None, '/tmp/stdout.txt', None,
                            None, 0, False, error)

launches a new process by passing nothing for both the args and the envs
and redirect the standard output of the inferior to the /tmp/stdout.txt
file. It does not specify a working directory so that the debug server
will use its idea of what the current working directory is for the
inferior. Also, we ask the debugger not to stop the inferior at the
entry point. If no breakpoint is specified for the inferior, it should
run to completion if no user interaction is required.

SBTarget_LaunchSimple(...)


SBTarget_LaunchSimple(SBTarget self, char const ** argv, char const ** envp, char const * working_directory) -> SBProcess

//------------------------------------------------------------------
/// Launch a new process with sensible defaults.
///
/// @param[in] argv
///     The argument array.
///
/// @param[in] envp
///     The environment array.
///
/// @param[in] working_directory
///     The working directory to have the child process run in
///
/// Default: listener
///     Set to the target's debugger (SBTarget::GetDebugger())
///
/// Default: launch_flags
///     Empty launch flags
///
/// Default: stdin_path
/// Default: stdout_path
/// Default: stderr_path
///     A pseudo terminal will be used.
///
/// @return
///      A process object for the newly created process.
//------------------------------------------------------------------

For example,

    process = target.LaunchSimple(['X', 'Y', 'Z'], None, os.getcwd())

launches a new process by passing 'X', 'Y', 'Z' as the args to the
executable.

SBTarget_LoadCore(...)


SBTarget_LoadCore(SBTarget self, char const * core_file) -> SBProcess

//------------------------------------------------------------------
/// Load a core file
///
/// @param[in] core_file
///     File path of the core dump.
///
/// @return
///      A process object for the newly created core file.
//------------------------------------------------------------------

For example,

    process = target.LoadCore('./a.out.core')

loads a new core file and returns the process object.

SBThread_GetStopReasonDataAtIndex(...)

SBThread_GetStopReasonDataAtIndex(SBThread self, uint32_t idx) -> uint64_t

//-------------------------------------------------------------------------- /// Get information associated with a stop reason. /// /// Breakpoint stop reasons will have data that consists of pairs of /// breakpoint IDs followed by the breakpoint location IDs (they always come /// in pairs). /// /// Stop Reason Count Data Type /// ======================== ===== ========================================= /// eStopReasonNone 0 /// eStopReasonTrace 0 /// eStopReasonBreakpoint N duple: {breakpoint id, location id} /// eStopReasonWatchpoint 1 watchpoint id /// eStopReasonSignal 1 unix signal number /// eStopReasonException N exception data /// eStopReasonExec 0 /// eStopReasonPlanComplete 0 //--------------------------------------------------------------------------

SBThread_GetStopReasonDataCount(...)

SBThread_GetStopReasonDataCount(SBThread self) -> size_t

/// Get the number of words associated with the stop reason. /// See also GetStopReasonDataAtIndex().

SBThread_Suspend(...)

SBThread_Suspend(SBThread self) -> bool

//-------------------------------------------------------------------------- /// LLDB currently supports process centric debugging which means when any /// thread in a process stops, all other threads are stopped. The Suspend() /// call here tells our process to suspend a thread and not let it run when /// the other threads in a process are allowed to run. So when /// SBProcess::Continue() is called, any threads that aren't suspended will /// be allowed to run. If any of the SBThread functions for stepping are /// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the /// thread will now be allowed to run and these funtions will simply return. /// /// Eventually we plan to add support for thread centric debugging where /// each thread is controlled individually and each thread would broadcast /// its state, but we haven't implemented this yet. /// /// Likewise the SBThread::Resume() call will again allow the thread to run /// when the process is continued. /// /// Suspend() and Resume() functions are not currently reference counted, if /// anyone has the need for them to be reference counted, please let us /// know. //--------------------------------------------------------------------------

SBValue_GetData(...)


SBValue_GetData(SBValue self) -> SBData

//------------------------------------------------------------------
   /// Get an SBData wrapping the contents of this SBValue.
   ///
   /// This method will read the contents of this object in memory
   /// and copy them into an SBData for future use. 
   ///
   /// @return
   ///     An SBData with the contents of this SBValue, on success.
   ///     An empty SBData otherwise.
   //------------------------------------------------------------------

SBValue_GetIndexOfChildWithName(...)

SBValue_GetIndexOfChildWithName(SBValue self, char const * name) -> uint32_t

//------------------------------------------------------------------ /// Returns the child member index. /// /// Matches children of this object only and will match base classes and /// member names if this is a clang typed object. /// /// @param[in] name /// The name of the child value to get /// /// @return /// An index to the child member value. //------------------------------------------------------------------

SBValue_GetPointeeData(...)


GetPointeeData(uint32_t item_idx=0, uint32_t item_count=1) -> SBData
GetPointeeData(uint32_t item_idx=0) -> SBData
SBValue_GetPointeeData(SBValue self) -> SBData

//------------------------------------------------------------------
   /// Get an SBData wrapping what this SBValue points to.
   ///
   /// This method will dereference the current SBValue, if its
   /// data type is a T* or T[], and extract item_count elements
   /// of type T from it, copying their contents in an SBData. 
   ///
   /// @param[in] item_idx
   ///     The index of the first item to retrieve. For an array
   ///     this is equivalent to array[item_idx], for a pointer
   ///     to *(pointer + item_idx). In either case, the measurement
   ///     unit for item_idx is the sizeof(T) rather than the byte
   ///
   /// @param[in] item_count
   ///     How many items should be copied into the output. By default
   ///     only one item is copied, but more can be asked for.
   ///
   /// @return
   ///     An SBData with the contents of the copied items, on success.
   ///     An empty SBData otherwise.
   //------------------------------------------------------------------

SBValue_GetValueForExpressionPath(...)

SBValue_GetValueForExpressionPath(SBValue self, char const * expr_path) -> SBValue

Expands nested expressions like .a->b[0].c[1]->d.

SBValue_Watch(...)

SBValue_Watch(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint

/// Find and watch a variable. /// It returns an SBWatchpoint, which may be invalid.

SBValue_WatchPointee(...)

SBValue_WatchPointee(SBValue self, bool resolve_location, bool read, bool write, SBError error) -> SBWatchpoint

/// Find and watch the location pointed to by a variable. /// It returns an SBWatchpoint, which may be invalid.

SBWatchpoint_GetCondition(...)

SBWatchpoint_GetCondition(SBWatchpoint self) -> char const *

//------------------------------------------------------------------ /// Get the condition expression for the watchpoint. //------------------------------------------------------------------

SBWatchpoint_GetHardwareIndex(...)

SBWatchpoint_GetHardwareIndex(SBWatchpoint self) -> int32_t

//------------------------------------------------------------------ /// With -1 representing an invalid hardware index. //------------------------------------------------------------------

SBWatchpoint_SetCondition(...)

SBWatchpoint_SetCondition(SBWatchpoint self, char const * condition)

//-------------------------------------------------------------------------- /// The watchpoint stops only if the condition expression evaluates to true. //--------------------------------------------------------------------------