Class SBTarget

GetPlatform(SBTarget self) -> SBPlatform

Return the platform object associated with the target.

After return, the platform object should be checked for
validity.

@return
    A platform object.

Install(SBTarget self) -> SBError

Install any binaries that need to be installed.

This function does nothing when debugging on the host system.
When connected to remote platforms, the target's main executable
and any modules that have their install path set will be
installed on the remote platform. If the main executable doesn't
have an install location set, it will be installed in the remote
platform's working directory.

@return
    An error describing anything that went wrong during
    installation.

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.

Launch(SBTarget self, 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
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_entry
    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.

LoadCore(SBTarget self, char const * core_file) -> SBProcess
LoadCore(SBTarget self, char const * core_file, SBError error) -> SBProcess

Load a core file

@param[in] core_file
    File path of the core dump.

@param[out] error
    An error explaining what went wrong if the operation fails.
    (Optional)

@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.

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.

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.

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.

AppendImageSearchPath(SBTarget self, char const * _from, char const * to, SBError error)

Append the path mapping (from -> to) to the target's paths mapping list.

FindCompileUnits(SBTarget self, SBFileSpec sb_file_spec) -> SBSymbolContextList

Find compile units related to *this target and passed source
file.

@param[in] sb_file_spec
    A lldb::SBFileSpec object that contains source file
    specification.

@return
    A lldb::SBSymbolContextList that gets filled in with all of
    the symbol contexts for all the matches.

GetDataByteSize(SBTarget self) -> uint32_t

Architecture data byte width accessor

@return The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's data bus

GetCodeByteSize(SBTarget self) -> uint32_t

Architecture code byte width accessor

@return The size in 8-bit (host) bytes of a minimum addressable unit from the Architecture's code bus

FindFunctions(SBTarget self, char const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList
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.

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).

FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches) -> SBValueList
FindGlobalVariables(SBTarget self, char const * name, uint32_t max_matches, lldb::MatchType matchtype) -> 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.

ResolveFileAddress(SBTarget self, lldb::addr_t file_addr) -> SBAddress

Resolve a current file address into a section offset address.

@param[in] file_addr

@return
    An SBAddress which will be valid if...

ReadMemory(SBTarget self, SBAddress addr, void * buf, SBError error) -> size_t

Read target memory. If a target process is running then memory
is read from here. Otherwise the memory is read from the object
files. For a target whose bytes are sized as a multiple of host
bytes, the data read back will preserve the target's byte order.

@param[in] addr
    A target address to read from.

@param[out] buf
    The buffer to read memory into.

@param[in] size
    The maximum number of host bytes to read in the buffer passed
    into this call

@param[out] error
    Error information is written here if the memory read fails.

@return
    The amount of data read in host bytes.

BreakpointCreateByName(SBTarget self, char const * symbol_name, char const * module_name=None) -> SBBreakpoint
BreakpointCreateByName(SBTarget self, char const * symbol_name) -> SBBreakpoint
BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t func_name_type, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
BreakpointCreateByName(SBTarget self, char const * symbol_name, uint32_t func_name_type, lldb::LanguageType symbol_language, 
    SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint

BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, 
    SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
BreakpointCreateByNames(SBTarget self, char const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language, 
    lldb::addr_t offset, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint

BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, char const * module_name=None) -> SBBreakpoint
BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex) -> SBBreakpoint
BreakpointCreateByRegex(SBTarget self, char const * symbol_name_regex, lldb::LanguageType symbol_language, SBFileSpecList module_list, 
    SBFileSpecList comp_unit_list) -> SBBreakpoint

BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpec source_file, char const * module_name=None) -> SBBreakpoint
BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpec source_file) -> SBBreakpoint
BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpecList module_list, SBFileSpecList file_list) -> SBBreakpoint
BreakpointCreateBySourceRegex(SBTarget self, char const * source_regex, SBFileSpecList module_list, SBFileSpecList source_file, 
    SBStringList func_names) -> SBBreakpoint

BreakpointCreateFromScript(SBTarget self, char const * class_name, SBStructuredData extra_args, SBFileSpecList module_list, 
    SBFileSpecList file_list, bool request_hardware=False) -> SBBreakpoint
BreakpointCreateFromScript(SBTarget self, char const * class_name, SBStructuredData extra_args, SBFileSpecList module_list, 
    SBFileSpecList file_list) -> SBBreakpoint

Create a breakpoint using a scripted resolver.

@param[in] class_name
   This is the name of the class that implements a scripted resolver.
   The class should have the following signature:
   class Resolver:
       def __init__(self, bkpt, extra_args):
           # bkpt - the breakpoint for which this is the resolver.  When
           # the resolver finds an interesting address, call AddLocation
           # on this breakpoint to add it.
           #
           # extra_args - an SBStructuredData that can be used to
           # parametrize this instance.  Same as the extra_args passed
           # to BreakpointCreateFromScript.

       def __get_depth__ (self):
           # This is optional, but if defined, you should return the
           # depth at which you want the callback to be called.  The
           # available options are:
           #    lldb.eSearchDepthModule
           #    lldb.eSearchDepthCompUnit
           # The default if you don't implement this method is
           # eSearchDepthModule.

       def __callback__(self, sym_ctx):
           # sym_ctx - an SBSymbolContext that is the cursor in the
           # search through the program to resolve breakpoints.
           # The sym_ctx will be filled out to the depth requested in
           # __get_depth__.
           # Look in this sym_ctx for new breakpoint locations,
           # and if found use bkpt.AddLocation to add them.
           # Note, you will only get called for modules/compile_units that
           # pass the SearchFilter provided by the module_list & file_list
           # passed into BreakpointCreateFromScript.

       def get_short_help(self):
           # Optional, but if implemented return a short string that will
           # be printed at the beginning of the break list output for the
           # breakpoint.

@param[in] extra_args
   This is an SBStructuredData object that will get passed to the
   constructor of the class in class_name.  You can use this to
   reuse the same class, parametrizing it with entries from this
   dictionary.

@param module_list
   If this is non-empty, this will be used as the module filter in the
   SearchFilter created for this breakpoint.

@param file_list
   If this is non-empty, this will be used as the comp unit filter in the
   SearchFilter created for this breakpoint.

@return
    An SBBreakpoint that will set locations based on the logic in the
    resolver's search callback.

BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBBreakpointList bkpt_list) -> SBError
BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBStringList matching_names, SBBreakpointList new_bps) -> SBError

Read breakpoints from source_file and return the newly created
breakpoints in bkpt_list.

@param[in] source_file
   The file from which to read the breakpoints

@param[in] matching_names
   Only read in breakpoints whose names match one of the names in this
   list.

@param[out] bkpt_list
   A list of the newly created breakpoints.

@return
    An SBError detailing any errors in reading in the breakpoints.

CreateValueFromAddress(SBTarget self, char const * name, SBAddress addr, SBType type) -> SBValue

Create an SBValue with the given name by treating the memory starting at addr as an entity of type.

@param[in] name
    The name of the resultant SBValue

@param[in] addr
    The address of the start of the memory region to be used.

@param[in] type
    The type to use to interpret the memory starting at addr.

@return
    An SBValue of the given type, may be invalid if there was an error reading
    the underlying memory.

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

Disassemble a specified number of instructions starting at an address.
Parameters:
   base_addr       -- the address to start disassembly from
   count           -- the number of instructions to disassemble
   flavor_string   -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
Returns an SBInstructionList.

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

Disassemble the bytes in a buffer and return them in an SBInstructionList.
Parameters:
   base_addr -- used for symbolicating the offsets in the byte stream when disassembling
   buf       -- bytes to be disassembled
   size      -- (C++) size of the buffer
Returns an SBInstructionList.

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

Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.
Parameters:
   base_addr -- used for symbolicating the offsets in the byte stream when disassembling
   flavor    -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
   buf       -- bytes to be disassembled
   size      -- (C++) size of the buffer
Returns an SBInstructionList.

eBroadcastBitBreakpointChanged

Value:

_lldb.SBTarget_eBroadcastBitBreakpointChanged

eBroadcastBitModulesLoaded

Value:

_lldb.SBTarget_eBroadcastBitModulesLoaded

eBroadcastBitModulesUnloaded

Value:

_lldb.SBTarget_eBroadcastBitModulesUnloaded

eBroadcastBitWatchpointChanged

Value:

_lldb.SBTarget_eBroadcastBitWatchpointChanged

eBroadcastBitSymbolsLoaded

Value:

_lldb.SBTarget_eBroadcastBitSymbolsLoaded