Struct lldb::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 launch.

use lldb::*;
fn launch_target(target: &SBTarget) -> Result<SBProcess, SBError> {
    let launch_info = SBLaunchInfo::new();
    launch_info.set_launch_flags(LAUNCH_FLAG_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 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.

Methods

impl SBTarget

fn wrap(raw: SBTargetRef) -> SBTarget

Construct a new SBTarget.

fn maybe_wrap(raw: SBTargetRef) -> Option<SBTarget>

Construct a new Some(SBTarget) or None.

fn is_valid(&self) -> bool

Check whether or not this is a valid SBTarget value.

fn broadcaster_class_name() -> &'static str

fn platform(&self) -> SBPlatform

Get the SBPlatform associated with this target.

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

fn process(&self) -> SBProcess

Get the SBProcess associated with this target.

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

Launch a target for debugging.

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

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

Get a filespec for the executable.

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

Add a module to the target.

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

Add a module to the target using an SBModuleSpec.

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

Remove a module from the target.

fn debugger(&self) -> SBDebugger

Get the debugger controlling this target.

fn modules(&self) -> SBTargetModuleIter

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

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

Find the module for the given SBFileSpec.

fn delete_breakpoint(&self, break_id: i32)

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

fn enable_all_breakpoints(&self)

fn disable_all_breakpoints(&self)

fn delete_all_breakpoints(&self)

fn breakpoints(&self) -> SBTargetBreakpointIter

fn delete_watchpoint(&self, watch_id: i32)

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

fn enable_all_watchpoints(&self)

fn disable_all_watchpoints(&self)

fn delete_all_watchpoints(&self)

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

fn watchpoints(&self) -> SBTargetWatchpointIter

fn broadcaster(&self) -> SBBroadcaster

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

Evaluate an expression.

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

Trait Implementations

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.