Struct gdb_command::GdbCommand

pub struct GdbCommand<'a> { /* private fields */ }

Struct contains information about arguments for gdb to run.

Implementations

impl<'a> GdbCommand<'a>

pub fn new(exec_type: &'a ExecType<'_>) -> GdbCommand<'a>

Construct GdbCommand from given ExecType.

Arguments

• type - execution type to run gdb.

pub fn stdin<T: Into<Option<&'a PathBuf>>>(
    &mut self,
    file: T
) -> &'a mut GdbCommand<'_>

Add stdin for executable. You should call this method before using r method.

Arguments

• file - path to stdin file

pub fn ex<T: Into<String>>(&mut self, cmd: T) -> &'a mut GdbCommand<'_>

Add new gdb command to execute.

Arguments

• cmd - gdb command parameter (-ex).

Examples found in repository

src/lib.rs (line 204)

    pub fn bt(&mut self) -> &'a mut GdbCommand {
        self.ex("bt")
    }

    /// Add command to get disassembly (-ex 'x/16i $pc')
    pub fn disassembly(&mut self) -> &'a mut GdbCommand {
        self.ex("x/16i $pc")
    }

    /// Add command to get registers (-ex 'i r')
    pub fn regs(&mut self) -> &'a mut GdbCommand {
        self.ex("i r")
    }

    /// Add command to get mappings (-ex 'info proc mappings')
    pub fn mappings(&mut self) -> &'a mut GdbCommand {
        self.ex("info proc mappings")
    }

    /// Add command to get cmd line.
    pub fn cmdline(&mut self) -> &'a mut GdbCommand {
        self.ex("info proc cmdline")
    }

    /// Add command to get environment variables
    pub fn env(&mut self) -> &'a mut GdbCommand {
        self.ex("show environment")
    }

    /// Add command to get process status
    pub fn status(&mut self) -> &'a mut GdbCommand {
        self.ex("info proc status")
    }

    /// Add command to get info
    pub fn sources(&mut self) -> &'a mut GdbCommand {
        self.ex("info sources")
    }

    /// Break at main
    pub fn bmain(&mut self) -> &'a mut GdbCommand {
        self.args.push("-ex".to_string());
        self.args.push("b main".to_string());
        self
    }

    /// Print lines from source file
    ///
    /// # Arguments
    ///
    /// * `location` - lines centered around the line specified by location.
    /// If None then location is current line.
    pub fn list<T: Into<Option<&'a str>>>(&mut self, location: T) -> &'a mut GdbCommand {
        if let Some(loc) = location.into() {
            self.ex(format!("list {}", loc))
        } else {
            self.ex("list")
        }
    }

    /// Get memory contents (string of hex bytes)
    ///
    /// # Arguments
    ///
    /// * `expr` - expression that represents the start memory address.
    ///
    /// * `size` - size of memory in bytes to get.
    pub fn mem<T: AsRef<str>>(&mut self, expr: T, size: usize) -> &'a mut GdbCommand {
        self.ex(format!("x/{}bx {}", size, expr.as_ref()))
    }

    /// Add command to get siginfo
    pub fn siginfo(&mut self) -> &'a mut GdbCommand {
        self.ex("p/x $_siginfo")
    }

pub fn raw(&self) -> Result<Vec<u8>>

Run gdb with provided commands and return raw stdout.

Examples found in repository

src/lib.rs (line 285)

    pub fn launch(&self) -> error::Result<Vec<String>> {
        // Get raw output from Gdb.
        let stdout = self.raw()?;

        // Split stdout into lines.
        let output = String::from_utf8_lossy(&stdout);

        self.parse(output)
    }

pub fn r(&mut self) -> &'a mut GdbCommand<'_>

Add command to run program

Arguments

• file - path to stdin file

pub fn c(&mut self) -> &'a mut GdbCommand<'_>

Add command to continue execution

pub fn bt(&mut self) -> &'a mut GdbCommand<'_>

Add command to get backtrace (-ex bt)

pub fn disassembly(&mut self) -> &'a mut GdbCommand<'_>

Add command to get disassembly (-ex ‘x/16i $pc’)

pub fn regs(&mut self) -> &'a mut GdbCommand<'_>

Add command to get registers (-ex ‘i r’)

pub fn mappings(&mut self) -> &'a mut GdbCommand<'_>

Add command to get mappings (-ex ‘info proc mappings’)

pub fn cmdline(&mut self) -> &'a mut GdbCommand<'_>

Add command to get cmd line.

pub fn env(&mut self) -> &'a mut GdbCommand<'_>

Add command to get environment variables

pub fn status(&mut self) -> &'a mut GdbCommand<'_>

Add command to get process status

pub fn sources(&mut self) -> &'a mut GdbCommand<'_>

Add command to get info

pub fn bmain(&mut self) -> &'a mut GdbCommand<'_>

Break at main

pub fn list<T: Into<Option<&'a str>>>(
    &mut self,
    location: T
) -> &'a mut GdbCommand<'_>

Print lines from source file

Arguments

• location - lines centered around the line specified by location. If None then location is current line.

pub fn mem<T: AsRef<str>>(
    &mut self,
    expr: T,
    size: usize
) -> &'a mut GdbCommand<'_>

Get memory contents (string of hex bytes)

Arguments

• expr - expression that represents the start memory address.

• size - size of memory in bytes to get.

pub fn siginfo(&mut self) -> &'a mut GdbCommand<'_>

Add command to get siginfo

pub fn launch(&self) -> Result<Vec<String>>

Execute gdb and get result for each command.

Return value.

The return value is a vector of strings for each command executed.

pub fn parse<T: AsRef<str>>(&self, output: T) -> Result<Vec<String>>

Parse raw gdb output.

Return value.

The return value is a vector of strings for each command executed.

Examples found in repository

src/lib.rs (line 290)

    pub fn launch(&self) -> error::Result<Vec<String>> {
        // Get raw output from Gdb.
        let stdout = self.raw()?;

        // Split stdout into lines.
        let output = String::from_utf8_lossy(&stdout);

        self.parse(output)
    }

Trait Implementations

impl<'a> Debug for GdbCommand<'a>

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

Formats the value using the given formatter.