Struct SBTarget 

pub struct SBTarget {
    pub raw: SBTargetRef,
}

The target program running under the debugger.

Process Management

Starting a debug session is done by launching the target, attaching to a running process, or loading a core file.

Launching

Launching a process can be done by creating and filling out an SBLaunchInfo and calling SBTarget::launch().

use lldb::*;
fn launch_target(target: &SBTarget) -> Result<SBProcess, SBError> {
    let launch_info = SBLaunchInfo::new();
    launch_info.set_launch_flags(LaunchFlags::STOP_AT_ENTRY);
    // Probably want to set up a listener here.
    target.launch(launch_info)
}

Attaching

Attaching to a process can be done by creating and filling out an SBAttachInfo and calling SBTarget::attach().

use lldb::{lldb_pid_t, SBAttachInfo, SBError, SBProcess, SBTarget};
fn attach_to_pid(target: &SBTarget, pid: lldb_pid_t) -> Result<SBProcess, SBError> {
    let attach_info = SBAttachInfo::new_with_pid(pid);
    // Probably want to set up a listener here.
    target.attach(attach_info)
}

Core Files

…

Breakpoints and Watchpoints

…

Modules

…

Events

…

Fields

raw: SBTargetRef

The underlying raw SBTargetRef.

Implementations

impl SBTarget

pub fn is_valid(&self) -> bool

Check whether or not this is a valid SBTarget value.

pub fn broadcaster_class_name() -> &'static str

pub fn platform(&self) -> SBPlatform

Get the SBPlatform associated with this target.

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

pub fn process(&self) -> SBProcess

Get the SBProcess associated with this target.

pub fn launch(&self, launch_info: SBLaunchInfo) -> Result<SBProcess, SBError>

Launch a target for debugging.

Examples found in repository

examples/basic_synchronous.rs (line 15)

fn main() {
    SBDebugger::initialize();

    let debugger = SBDebugger::create(false);
    debugger.set_asynchronous(false);
    println!("{debugger:?}");

    if let Some(target) = debugger.create_target_simple("/usr/local/bin/servo") {
        println!("{target:?}");

        let launchinfo = SBLaunchInfo::new();
        launchinfo.set_launch_flags(LaunchFlags::STOP_AT_ENTRY);
        match target.launch(launchinfo) {
            Ok(process) => {
                println!("{process:?}");
                let _ = process.continue_execution();
                println!("{process:?}");
            }
            Err(e) => println!("Uhoh: {e:?}"),
        }
    }
    SBDebugger::terminate();
}

pub fn load_core(&self, core_file: &str) -> Result<SBProcess, SBError>

pub fn attach(&self, attach_info: SBAttachInfo) -> Result<SBProcess, SBError>

pub fn executable(&self) -> Option<SBFileSpec>

Get a filespec for the executable.

pub fn add_module(&self, module: &SBModule) -> bool

Add a module to the target.

pub fn add_module_spec(&self, module_spec: &SBModuleSpec) -> Option<SBModule>

Add a module to the target using an SBModuleSpec.

pub fn remove_module(&self, module: &SBModule) -> bool

Remove a module from the target.

pub fn debugger(&self) -> SBDebugger

Get the debugger controlling this target.

pub fn modules(&self) -> SBTargetModuleIter<'_>

Get an iterator over the modules known to this target instance.

pub fn find_module(&self, file_spec: &SBFileSpec) -> Option<SBModule>

Find the module for the given SBFileSpec.

pub fn resolve_file_address(&self, file_addr: lldb_addr_t) -> Option<SBAddress>

Resolve a current file address into a section offset address.

pub fn resolve_load_address(&self, vm_addr: lldb_addr_t) -> Option<SBAddress>

Resolve a current load address into a section offset address.

The return value will be None if the vm_addr doesn’t resolve to a section within a module.

pub fn delete_breakpoint(&self, break_id: i32)

pub fn find_breakpoint_by_id(&self, break_id: i32) -> Option<SBBreakpoint>

pub fn enable_all_breakpoints(&self)

pub fn disable_all_breakpoints(&self)

pub fn delete_all_breakpoints(&self)

pub fn breakpoint_create_by_location( &self, file: &str, line: u32, ) -> SBBreakpoint

pub fn breakpoint_create_by_address(&self, address: lldb_addr_t) -> SBBreakpoint

pub fn breakpoint_create_by_sbaddress(&self, address: SBAddress) -> SBBreakpoint

pub fn breakpoints(&self) -> SBTargetBreakpointIter<'_>

pub fn delete_watchpoint(&self, watch_id: i32)

pub fn find_watchpoint_by_id(&self, watch_id: i32) -> Option<SBWatchpoint>

pub fn enable_all_watchpoints(&self)

pub fn disable_all_watchpoints(&self)

pub fn delete_all_watchpoints(&self)

pub fn watch_address( &self, addr: lldb_addr_t, size: usize, read: bool, write: bool, ) -> Result<SBWatchpoint, SBError>

pub fn watchpoints(&self) -> SBTargetWatchpointIter<'_>

pub fn broadcaster(&self) -> SBBroadcaster

pub fn find_functions( &self, name: &str, name_type_mask: u32, ) -> SBSymbolContextList

pub fn find_global_functions( &self, name: &str, max_matches: u32, matchtype: MatchType, ) -> SBSymbolContextList

pub fn find_symbols( &self, name: &str, symbol_type: SymbolType, ) -> SBSymbolContextList

pub fn evaluate_expression( &self, expression: &str, options: &SBExpressionOptions, ) -> SBValue

Evaluate an expression.

pub fn event_as_target_event(event: &SBEvent) -> Option<SBTargetEvent<'_>>

pub fn get_stack_red_zone_size(&self) -> lldb_addr_t

pub fn is_loaded(&self, module: &SBModule) -> bool

pub fn get_launch_info(&self) -> SBLaunchInfo

pub fn set_launch_info(&self, launch_info: SBLaunchInfo)

pub fn byte_order(&self) -> ByteOrder

Returns the byte order of target

pub fn get_address_byte_size(&self) -> u32

Returns the size of address in bytes

Trait Implementations

impl Clone for SBTarget

fn clone(&self) -> SBTarget

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SBTarget

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for SBTarget

fn drop(&mut self)

Executes the destructor for this type.

impl Send for SBTarget

impl Sync for SBTarget