Class SBProcess

Writes data into the current process's stdin. API client specifies a Python string as the only argument.

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.

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.

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.

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.

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.

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.

Destroy(SBProcess self) -> SBError

Kills the process and shuts down all threads that were spawned to track and monitor process.

Signal(SBProcess self, int signal) -> SBError

Sends the process a unix signal.

GetStopID(SBProcess self, bool include_expression_stops=False) -> uint32_t 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.

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) new_bytes = bytearray(content)

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!')

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)

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)

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)

Load the library whose filename is given by image_spec looking in all the paths supplied in the paths argument. If successful, return a token that can be passed to UnloadImage and fill loaded_path with the path that was successfully loaded. On failure, return lldb.LLDB_INVALID_IMAGE_TOKEN.

Return the number of different thread-origin extended backtraces this process can support as a uint32_t. When the process is stopped and you have an SBThread, lldb may be able to show a backtrace of when that thread was originally created, or the work item was enqueued to it (in the case of a libdispatch queue).

Get information about the process.
Valid process info will only be returned when the process is alive,
use IsValid() to check if the info returned is valid.

process_info = process.GetProcessInfo()
if process_info.IsValid():
    process_info.GetProcessID()

eBroadcastBitStateChanged

Value:

_lldb.SBProcess_eBroadcastBitStateChanged

eBroadcastBitProfileData

Value:

_lldb.SBProcess_eBroadcastBitProfileData

eBroadcastBitStructuredData

Value:

_lldb.SBProcess_eBroadcastBitStructuredData