Struct Instruction 

pub struct Instruction {
    pub prefixes: Prefixes,
    pub mnemonic: Mnemonic,
    pub operands: InstructionOperands,
}

an instruction.

Fields

prefixes: Prefixes

the instruction’s prefixes.

mnemonic: Mnemonic

the instruction’s mnemonic.

operands: InstructionOperands

the instruction’s explicit operands, which are the operands that are specified in the instruction’s textual representation.

Implementations

impl Instruction

pub fn memory_operand(&self) -> Option<&MemOperand>

returns the memory operand of this instruction, if any.

pub fn format( &self, state: &RydisState, style: FormatStyle, runtime_address: Option<u64>, ) -> Result<FormattedInstruction>

formats this instruction into a string.

Examples found in repository

examples/basic.rs (line 35)

fn main() -> rydis::Result<()> {
    let state = rydis::RydisState::new(MachineMode::Long64, StackWidth::Width64)?;

    // encode an instruction
    let encoded = state.encode(Instruction {
        prefixes: Prefixes::empty(),
        mnemonic: Mnemonic::XCHG,
        operands: [Operand::Reg(Register::RAX), Operand::Reg(Register::RBX)]
            .into_iter()
            .collect(),
    })?;
    println!("encoded = {:x?}", encoded);

    // decode it
    let decoded_instruction = state.decode_one(encoded.as_slice())?;

    // modify it
    let mut modified_instruction = decoded_instruction.to_instruction();
    modified_instruction.operands[1] = Operand::Mem(MemOperand {
        base: Some(Register::RBP),
        index: None,
        displacement: 0x1234,
        size: decoded_instruction.operand_width,
        segment_register_override: None,
    });

    // format it
    println!(
        "modified insn: {}",
        modified_instruction.format(&state, FormatStyle::Intel, Some(0x123400))?
    );

    // re-encode the modified instruction
    let re_encoded = state.encode(modified_instruction)?;
    println!("re-encoded = {:x?}", re_encoded);

    Ok(())
}

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl Hash for Instruction

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Instruction

fn eq(&self, other: &Instruction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Instruction

impl StructuralPartialEq for Instruction