lldb.SBTarget

Package lldb :: Class SBTarget |
[hide private]
[frames] | no frames]

# Class SBTarget

source code

    Represents the target program running under the debugger.

    SBTarget supports module, breakpoint, and watchpoint iterations. For example,

        for m in target.module_iter():
            print m

    produces:

    (x86_64) /Volumes/data/lldb/svn/trunk/test/python_api/lldbutil/iter/a.out
    (x86_64) /usr/lib/dyld
    (x86_64) /usr/lib/libstdc++.6.dylib
    (x86_64) /usr/lib/libSystem.B.dylib
    (x86_64) /usr/lib/system/libmathCommon.A.dylib
    (x86_64) /usr/lib/libSystem.B.dylib(__commpage)

    and,

        for b in target.breakpoint_iter():
            print b

    produces:

    SBBreakpoint: id = 1, file ='main.cpp', line = 66, locations = 1
    SBBreakpoint: id = 2, file ='main.cpp', line = 85, locations = 1

    and,

        for wp_loc in target.watchpoint_iter():
            print wp_loc

    produces:

    Watchpoint 1: addr = 0x1034ca048 size = 4 state = enabled type = rw
        declare @ '/Volumes/data/lldb/svn/trunk/test/python_api/watchpoint/main.c:12'
        hw_index = 0  hit_count = 2     ignore_count = 0

Nested Classes | [hide private]
| modules_access A helper object that will lazily hand out lldb.SBModule objects for a target when supplied an index, or by full or partial path.

Instance Methods | [hide private]
__setattr__(self, name, value) x.__setattr__('name', value) <==> x.name = value | source code
__getattr__(self, name) | source code
__repr__(self) repr(x) | source code
module_iter(self) | source code
breakpoint_iter(self) | source code
watchpoint_iter(self) | source code
__init__(self, *args) __init__(lldb::SBTarget self) -> SBTarget __init__(lldb::SBTarget self, SBTarget rhs) -> SBTarget | source code
__swig_destroy__(...) delete_SBTarget(SBTarget self) |
__del__(self) | source code
__nonzero__(self) | source code
IsValid(self) IsValid(SBTarget self) -> bool | source code
GetProcess(self) GetProcess(SBTarget self) -> SBProcess | source code
GetPlatform(self) GetPlatform(SBTarget self) -> SBPlatform | source code
Install(self) Install(SBTarget self) -> SBError | source code
LaunchSimple(self, *args) LaunchSimple(SBTarget self, str const ** argv, str const ** envp, str const * working_directory) -> SBProcess | source code
Launch(self, *args) Launch(SBTarget self, SBListener listener, str const ** argv, str const ** envp, str const * stdin_path, str const * stdout_path, str const * stderr_path, str const * working_directory, uint32_t launch_flags, bool stop_at_entry, SBError error) -> SBProcess Launch(SBTarget self, SBLaunchInfo launch_info, SBError error) -> SBProcess | source code
LoadCore(self, *args) LoadCore(SBTarget self, str const * core_file) -> SBProcess | source code
Attach(self, *args) Attach(SBTarget self, SBAttachInfo attach_info, SBError error) -> SBProcess | source code
AttachToProcessWithID(self, *args) AttachToProcessWithID(SBTarget self, SBListener listener, lldb::pid_t pid, SBError error) -> SBProcess | source code
AttachToProcessWithName(self, *args) AttachToProcessWithName(SBTarget self, SBListener listener, str const * name, bool wait_for, SBError error) -> SBProcess | source code
ConnectRemote(self, *args) ConnectRemote(SBTarget self, SBListener listener, str const * url, str const * plugin_name, SBError error) -> SBProcess | source code
GetExecutable(self) GetExecutable(SBTarget self) -> SBFileSpec | source code
AddModule(self, *args) AddModule(SBTarget self, SBModule module) -> bool AddModule(SBTarget self, str const * path, str const * triple, str const * uuid) -> SBModule AddModule(SBTarget self, str const * path, str const * triple, str const * uuid_cstr, str const * symfile) -> SBModule AddModule(SBTarget self, SBModuleSpec module_spec) -> SBModule | source code
GetNumModules(self) GetNumModules(SBTarget self) -> uint32_t | source code
GetModuleAtIndex(self, *args) GetModuleAtIndex(SBTarget self, uint32_t idx) -> SBModule | source code
RemoveModule(self, *args) RemoveModule(SBTarget self, SBModule module) -> bool | source code
GetDebugger(self) GetDebugger(SBTarget self) -> SBDebugger | source code
FindModule(self, *args) FindModule(SBTarget self, SBFileSpec file_spec) -> SBModule | source code
GetByteOrder(self) GetByteOrder(SBTarget self) -> lldb::ByteOrder | source code
GetAddressByteSize(self) GetAddressByteSize(SBTarget self) -> uint32_t | source code
GetTriple(self) GetTriple(SBTarget self) -> str const * | source code
GetDataByteSize(self) GetDataByteSize(SBTarget self) -> uint32_t | source code
GetCodeByteSize(self) GetCodeByteSize(SBTarget self) -> uint32_t | source code
SetSectionLoadAddress(self, *args) SetSectionLoadAddress(SBTarget self, SBSection section, lldb::addr_t section_base_addr) -> SBError | source code
ClearSectionLoadAddress(self, *args) ClearSectionLoadAddress(SBTarget self, SBSection section) -> SBError | source code
SetModuleLoadAddress(self, *args) SetModuleLoadAddress(SBTarget self, SBModule module, int64_t sections_offset) -> SBError | source code
ClearModuleLoadAddress(self, *args) ClearModuleLoadAddress(SBTarget self, SBModule module) -> SBError | source code
FindFunctions(self, *args) FindFunctions(SBTarget self, str const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList FindFunctions(SBTarget self, str const * name) -> SBSymbolContextList | source code
FindFirstType(self, *args) FindFirstType(SBTarget self, str const * type) -> SBType | source code
FindTypes(self, *args) FindTypes(SBTarget self, str const * type) -> SBTypeList | source code
GetBasicType(self, *args) GetBasicType(SBTarget self, lldb::BasicType type) -> SBType | source code
GetSourceManager(self) GetSourceManager(SBTarget self) -> SBSourceManager | source code
FindFirstGlobalVariable(self, *args) FindFirstGlobalVariable(SBTarget self, str const * name) -> SBValue | source code
FindGlobalVariables(self, *args) FindGlobalVariables(SBTarget self, str const * name, uint32_t max_matches) -> SBValueList FindGlobalVariables(SBTarget self, str const * name, uint32_t max_matches, lldb::MatchType matchtype) -> SBValueList | source code
FindGlobalFunctions(self, *args) FindGlobalFunctions(SBTarget self, str const * name, uint32_t max_matches, lldb::MatchType matchtype) -> SBSymbolContextList | source code
Clear(self) Clear(SBTarget self) | source code
ResolveFileAddress(self, *args) ResolveFileAddress(SBTarget self, lldb::addr_t file_addr) -> SBAddress | source code
ResolveLoadAddress(self, *args) ResolveLoadAddress(SBTarget self, lldb::addr_t vm_addr) -> SBAddress | source code
ResolvePastLoadAddress(self, *args) ResolvePastLoadAddress(SBTarget self, uint32_t stop_id, lldb::addr_t vm_addr) -> SBAddress | source code
ResolveSymbolContextForAddress(self, *args) ResolveSymbolContextForAddress(SBTarget self, SBAddress addr, uint32_t resolve_scope) -> SBSymbolContext | source code
ReadMemory(self, *args) ReadMemory(SBTarget self, SBAddress addr, void * buf, SBError error) -> size_t | source code
BreakpointCreateByLocation(self, *args) BreakpointCreateByLocation(SBTarget self, str const * file, uint32_t line) -> SBBreakpoint BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line) -> SBBreakpoint BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, lldb::addr_t offset) -> SBBreakpoint BreakpointCreateByLocation(SBTarget self, SBFileSpec file_spec, uint32_t line, lldb::addr_t offset, SBFileSpecList module_list) -> SBBreakpoint | source code
BreakpointCreateByName(self, *args) BreakpointCreateByName(SBTarget self, str const * symbol_name, str const * module_name=None) -> SBBreakpoint... | source code
BreakpointCreateByNames(self, *args) BreakpointCreateByNames(SBTarget self, str const ** symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint... | source code
BreakpointCreateByRegex(self, *args) BreakpointCreateByRegex(SBTarget self, str const * symbol_name_regex, str const * module_name=None) -> SBBreakpoint... | source code
BreakpointCreateBySourceRegex(self, *args) BreakpointCreateBySourceRegex(SBTarget self, str const * source_regex, SBFileSpec source_file, str const * module_name=None) -> SBBreakpoint... | source code
BreakpointCreateForException(self, *args) BreakpointCreateForException(SBTarget self, lldb::LanguageType language, bool catch_bp, bool throw_bp) -> SBBreakpoint | source code
BreakpointCreateByAddress(self, *args) BreakpointCreateByAddress(SBTarget self, lldb::addr_t address) -> SBBreakpoint | source code
BreakpointCreateBySBAddress(self, *args) BreakpointCreateBySBAddress(SBTarget self, SBAddress sb_address) -> SBBreakpoint | source code
GetNumBreakpoints(self) GetNumBreakpoints(SBTarget self) -> uint32_t | source code
GetBreakpointAtIndex(self, *args) GetBreakpointAtIndex(SBTarget self, uint32_t idx) -> SBBreakpoint | source code
BreakpointDelete(self, *args) BreakpointDelete(SBTarget self, lldb::break_id_t break_id) -> bool | source code
FindBreakpointByID(self, *args) FindBreakpointByID(SBTarget self, lldb::break_id_t break_id) -> SBBreakpoint | source code
FindBreakpointsByName(self, *args) FindBreakpointsByName(SBTarget self, str const * name, SBBreakpointList bkpt_list) -> bool | source code
EnableAllBreakpoints(self) EnableAllBreakpoints(SBTarget self) -> bool | source code
DisableAllBreakpoints(self) DisableAllBreakpoints(SBTarget self) -> bool | source code
DeleteAllBreakpoints(self) DeleteAllBreakpoints(SBTarget self) -> bool | source code
BreakpointsCreateFromFile(self, *args) BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBBreakpointList bkpt_list) -> SBError BreakpointsCreateFromFile(SBTarget self, SBFileSpec source_file, SBStringList matching_names, SBBreakpointList new_bps) -> SBError | source code
BreakpointsWriteToFile(self, *args) BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file) -> SBError BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file, SBBreakpointList bkpt_list, bool append=False) -> SBError BreakpointsWriteToFile(SBTarget self, SBFileSpec dest_file, SBBreakpointList bkpt_list) -> SBError | source code
GetNumWatchpoints(self) GetNumWatchpoints(SBTarget self) -> uint32_t | source code
GetWatchpointAtIndex(self, *args) GetWatchpointAtIndex(SBTarget self, uint32_t idx) -> SBWatchpoint | source code
DeleteWatchpoint(self, *args) DeleteWatchpoint(SBTarget self, lldb::watch_id_t watch_id) -> bool | source code
FindWatchpointByID(self, *args) FindWatchpointByID(SBTarget self, lldb::watch_id_t watch_id) -> SBWatchpoint | source code
EnableAllWatchpoints(self) EnableAllWatchpoints(SBTarget self) -> bool | source code
DisableAllWatchpoints(self) DisableAllWatchpoints(SBTarget self) -> bool | source code
DeleteAllWatchpoints(self) DeleteAllWatchpoints(SBTarget self) -> bool | source code
WatchAddress(self, *args) WatchAddress(SBTarget self, lldb::addr_t addr, size_t size, bool read, bool write, SBError error) -> SBWatchpoint | source code
GetBroadcaster(self) GetBroadcaster(SBTarget self) -> SBBroadcaster | source code
CreateValueFromAddress(self, *args) CreateValueFromAddress(SBTarget self, str const * name, SBAddress addr, SBType type) -> SBValue | source code
CreateValueFromData(self, *args) CreateValueFromData(SBTarget self, str const * name, SBData data, SBType type) -> SBValue | source code
CreateValueFromExpression(self, *args) CreateValueFromExpression(SBTarget self, str const * name, str const * expr) -> SBValue | source code
ReadInstructions(self, *args) ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count) -> SBInstructionList ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count, str const * flavor_string) -> SBInstructionList | source code
GetInstructions(self, *args) GetInstructions(SBTarget self, SBAddress base_addr, void const * buf) -> SBInstructionList | source code
GetInstructionsWithFlavor(self, *args) GetInstructionsWithFlavor(SBTarget self, SBAddress base_addr, str const * flavor_string, void const * buf) -> SBInstructionList | source code
FindSymbols(self, *args) FindSymbols(SBTarget self, str const * name, lldb::SymbolType type=eSymbolTypeAny) -> SBSymbolContextList FindSymbols(SBTarget self, str const * name) -> SBSymbolContextList | source code
GetDescription(self, *args) GetDescription(SBTarget self, SBStream description, lldb::DescriptionLevel description_level) -> bool | source code
GetStackRedZoneSize(self) GetStackRedZoneSize(SBTarget self) -> lldb::addr_t | source code
GetLaunchInfo(self) GetLaunchInfo(SBTarget self) -> SBLaunchInfo | source code
SetLaunchInfo(self, *args) SetLaunchInfo(SBTarget self, SBLaunchInfo launch_info) | source code
EvaluateExpression(self, *args) EvaluateExpression(SBTarget self, str const * expr) -> SBValue EvaluateExpression(SBTarget self, str const * expr, SBExpressionOptions options) -> SBValue | source code
get_modules_access_object(self) An accessor function that returns a modules_access() object which allows lazy module access from a lldb.SBTarget object. | source code
get_modules_array(self) An accessor function that returns a list() that contains all modules in a lldb.SBTarget object. | source code
__str__(self) __str__(SBTarget self) -> PyObject * | source code
__eq__(self, rhs) | source code
__ne__(self, rhs) | source code
Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__hash__`, `__new__`, `__reduce__`, `__reduce_ex__`, `__sizeof__`, `__subclasshook__`

Static Methods | [hide private]
str const * |
GetBroadcasterClassName() | source code
EventIsTargetEvent(*args) EventIsTargetEvent(SBEvent event) -> bool | source code
GetTargetFromEvent(*args) GetTargetFromEvent(SBEvent event) -> SBTarget | source code
GetNumModulesFromEvent(*args) GetNumModulesFromEvent(SBEvent event) -> uint32_t | source code
GetModuleAtIndexFromEvent(*args) GetModuleAtIndexFromEvent(uint32_t const idx, SBEvent event) -> SBModule | source code

Class Variables | [hide private]
| __swig_setmethods__ = ``{``}``
| __swig_getmethods__ = `{}`
| eBroadcastBitBreakpointChanged = `1`
| eBroadcastBitModulesLoaded = `2`
| eBroadcastBitModulesUnloaded = `4`
| eBroadcastBitWatchpointChanged = `8`
| eBroadcastBitSymbolsLoaded = `16`

Properties | [hide private]
| addr_size A read only property that returns the size in bytes of an address for this target.
| broadcaster A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this target.
| byte_order A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this target.
| code_byte_size A read only property that returns the size in host bytes of a byte in the code address space for this target.
| data_byte_size A read only property that returns the size in host bytes of a byte in the data address space for this target.
| debugger A read only property that returns an lldb object that represents the debugger (lldb.SBDebugger) that owns this target.
| executable A read only property that returns an lldb object that represents the main executable module (lldb.SBModule) for this target.
| module A read only property that returns an object that implements python operator overloading with the square brackets().\n target.module[<int>] allows array access to any modules.\n target.module[<str>] allows access to modules by basename, full path, or uuid string value.\n target.module[uuid.UUID()] allows module access by UUID.\n target.module[re] allows module access using a regular expression that matches the module full path.
| modules A read only property that returns a list() of lldb.SBModule objects contained in this target.
| num_breakpoints A read only property that returns the number of breakpoints that this target has as an integer.
| num_watchpoints A read only property that returns the number of watchpoints that this target has as an integer.
| platform A read only property that returns the platform associated with with this target.
| process A read only property that returns an lldb object that represents the process (lldb.SBProcess) that this target owns.
| triple A read only property that returns the target triple (arch-vendor-os) for this target as a string.
Inherited from `object`: `__class__`

Method Details | [hide private]

### __setattr__(self, name, value) | source code
x.__setattr__('name', value) <==> x.name = value Overrides: object.__setattr__ (inherited documentation)

### __repr__(self) (Representation operator) | source code
repr(x) Overrides: object.__repr__ (inherited documentation)

### __init__(self, *args) (Constructor) | source code
__init__(lldb::SBTarget self) -> SBTarget __init__(lldb::SBTarget self, SBTarget rhs) -> SBTarget Overrides: object.__init__

### GetPlatform(self) | source code
    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(self) | source code
    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(self, *args) | source code
    LaunchSimple(SBTarget self, str const ** argv, str const ** envp, str 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(self, *args) | source code
    Launch(SBTarget self, SBListener listener, str const ** argv, str const ** envp, str const * stdin_path,
        str const * stdout_path, str const * stderr_path, str 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(self, *args) | source code
    LoadCore(SBTarget self, str 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.

### AttachToProcessWithID(self, *args) | source code
    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(self, *args) | source code
    AttachToProcessWithName(SBTarget self, SBListener listener, str 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(self, *args) | source code
    ConnectRemote(SBTarget self, SBListener listener, str const * url, str 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.

### GetDataByteSize(self) | source code
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(self) | source code
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(self, *args) | source code
    FindFunctions(SBTarget self, str const * name, uint32_t name_type_mask=eFunctionNameTypeAny) -> SBSymbolContextList
    FindFunctions(SBTarget self, str 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(self, *args) | source code
    FindFirstGlobalVariable(SBTarget self, str 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(self, *args) | source code
    FindGlobalVariables(SBTarget self, str const * name, uint32_t max_matches) -> SBValueList
    FindGlobalVariables(SBTarget self, str 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(self, *args) | source code
    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(self, *args) | source code
    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(self, *args) | source code
    BreakpointCreateByName(SBTarget self, str const * symbol_name, str const * module_name=None) -> SBBreakpoint
    BreakpointCreateByName(SBTarget self, str const * symbol_name) -> SBBreakpoint
    BreakpointCreateByName(SBTarget self, str const * symbol_name, uint32_t func_name_type, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
    BreakpointCreateByName(SBTarget self, str const * symbol_name, uint32_t func_name_type, lldb::LanguageType symbol_language,
        SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint

### BreakpointCreateByNames(self, *args) | source code
    BreakpointCreateByNames(SBTarget self, str const ** symbol_name, uint32_t name_type_mask, SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
    BreakpointCreateByNames(SBTarget self, str const ** symbol_name, uint32_t name_type_mask, lldb::LanguageType symbol_language,
        SBFileSpecList module_list, SBFileSpecList comp_unit_list) -> SBBreakpoint
    BreakpointCreateByNames(SBTarget self, str 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(self, *args) | source code
    BreakpointCreateByRegex(SBTarget self, str const * symbol_name_regex, str const * module_name=None) -> SBBreakpoint
    BreakpointCreateByRegex(SBTarget self, str const * symbol_name_regex) -> SBBreakpoint
    BreakpointCreateByRegex(SBTarget self, str const * symbol_name_regex, lldb::LanguageType symbol_language, SBFileSpecList module_list,
        SBFileSpecList comp_unit_list) -> SBBreakpoint

### BreakpointCreateBySourceRegex(self, *args) | source code
    BreakpointCreateBySourceRegex(SBTarget self, str const * source_regex, SBFileSpec source_file, str const * module_name=None) -> SBBreakpoint
    BreakpointCreateBySourceRegex(SBTarget self, str const * source_regex, SBFileSpec source_file) -> SBBreakpoint
    BreakpointCreateBySourceRegex(SBTarget self, str const * source_regex, SBFileSpecList module_list, SBFileSpecList file_list) -> SBBreakpoint
    BreakpointCreateBySourceRegex(SBTarget self, str const * source_regex, SBFileSpecList module_list, SBFileSpecList source_file,
        SBStringList func_names) -> SBBreakpoint

### BreakpointsCreateFromFile(self, *args) | source code
    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(self, *args) | source code
    CreateValueFromAddress(SBTarget self, str 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(self, *args) | source code
    ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count) -> SBInstructionList
    ReadInstructions(SBTarget self, SBAddress base_addr, uint32_t count, str 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(self, *args) | source code
    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(self, *args) | source code
    GetInstructionsWithFlavor(SBTarget self, SBAddress base_addr, str 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.

### __str__(self) (Informal representation operator) | source code
__str__(SBTarget self) -> PyObject * Overrides: object.__str__

Property Details | [hide private]

### addr_size A read only property that returns the size in bytes of an address for this target. Get Method: GetAddressByteSize(self) - GetAddressByteSize(SBTarget self) -> uint32_t

### broadcaster A read only property that an lldb object that represents the broadcaster (lldb.SBBroadcaster) for this target. Get Method: GetBroadcaster(self) - GetBroadcaster(SBTarget self) -> SBBroadcaster

### byte_order A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this target. Get Method: GetByteOrder(self) - GetByteOrder(SBTarget self) -> lldb::ByteOrder

### code_byte_size A read only property that returns the size in host bytes of a byte in the code address space for this target. Get Method: GetCodeByteSize(self) - GetCodeByteSize(SBTarget self) -> uint32_t

### data_byte_size A read only property that returns the size in host bytes of a byte in the data address space for this target. Get Method: GetDataByteSize(self) - GetDataByteSize(SBTarget self) -> uint32_t

### debugger A read only property that returns an lldb object that represents the debugger (lldb.SBDebugger) that owns this target. Get Method: GetDebugger(self) - GetDebugger(SBTarget self) -> SBDebugger

### executable A read only property that returns an lldb object that represents the main executable module (lldb.SBModule) for this target. Get Method: GetExecutable(self) - GetExecutable(SBTarget self) -> SBFileSpec

### module A read only property that returns an object that implements python operator overloading with the square brackets().\n target.module[<int>] allows array access to any modules.\n target.module[<str>] allows access to modules by basename, full path, or uuid string value.\n target.module[uuid.UUID()] allows module access by UUID.\n target.module[re] allows module access using a regular expression that matches the module full path. Get Method: get_modules_access_object(self) - An accessor function that returns a modules_access() object which allows lazy module access from a lldb.SBTarget object.

### modules A read only property that returns a list() of lldb.SBModule objects contained in this target. This list is a list all modules that the target currently is tracking (the main executable and all dependent shared libraries). Get Method: get_modules_array(self) - An accessor function that returns a list() that contains all modules in a lldb.SBTarget object.

### num_breakpoints A read only property that returns the number of breakpoints that this target has as an integer. Get Method: GetNumBreakpoints(self) - GetNumBreakpoints(SBTarget self) -> uint32_t

### num_watchpoints A read only property that returns the number of watchpoints that this target has as an integer. Get Method: GetNumWatchpoints(self) - GetNumWatchpoints(SBTarget self) -> uint32_t

### platform A read only property that returns the platform associated with with this target. Get Method: GetPlatform(self) - GetPlatform(SBTarget self) -> SBPlatform

### process A read only property that returns an lldb object that represents the process (lldb.SBProcess) that this target owns. Get Method: GetProcess(self) - GetProcess(SBTarget self) -> SBProcess

### triple A read only property that returns the target triple (arch-vendor-os) for this target as a string. Get Method: GetTriple(self) - GetTriple(SBTarget self) -> str const *