Struct bddisasm::operand::Operand

pub struct Operand {
    pub info: OpInfo,
    pub size: OpSize,
    pub access: OpAccess,
    pub is_default: bool,
}

Describes an instruction operand.

Each operand type encodes different information. See OpInfo for details.

Examples

use bddisasm::{DecodedInstruction, DecodeMode, OpRegType, OpSize};

// `MOV       ah, byte ptr [rcx+rdx*2+0x8]`
let code = vec![0x8a, 0x64, 0x51, 0x08];
let ins = DecodedInstruction::decode(&code, DecodeMode::Bits64)?;

let operands = ins.operands();
let dst = operands[0];
let src = operands[1];

// Check the size of each operand
assert_eq!(dst.size, OpSize::Bytes(1));
assert_eq!(src.size, OpSize::Bytes(1));

// Check the type of the destination operand
assert!(dst.info.is_reg());
let dst_reg = dst.info.as_reg().unwrap();
assert_eq!(dst_reg.kind, OpRegType::Gpr);

Fields

info: OpInfo

Extended operand information.

size: OpSize

It indicates the actual amount of data used for processing. If the operand is a register, it MAY NOT indicate the register size. Use the info field to get the actual register size in these cases.

access: OpAccess

Access mode.

is_default: bool

true if the operand is default. This also applies to implicit operands.

Trait Implementations

impl Clone for Operand

fn clone(&self) -> Operand

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Operand

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

Formats the value using the given formatter.

impl Default for Operand

fn default() -> Operand

Returns the “default value” for a type.

impl Hash for Operand

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 Operand

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Operand

impl Eq for Operand

impl StructuralPartialEq for Operand