Struct zydis::ffi::DecodedInstruction

#[repr(C)]
pub struct DecodedInstruction {

    pub machine_mode: MachineMode,
    pub mnemonic: Mnemonic,
    pub length: u8,
    pub encoding: InstructionEncoding,
    pub opcode_map: OpcodeMap,
    pub opcode: u8,
    pub stack_width: u8,
    pub operand_width: u8,
    pub address_width: u8,
    pub operand_count: u8,
    pub operand_count_visible: u8,
    pub attributes: InstructionAttributes,
    pub cpu_flags: &'static AccessedFlags<CpuFlag>,
    pub fpu_flags: &'static AccessedFlags<FpuFlag>,
    pub avx: AvxInfo,
    pub meta: MetaInfo,
    pub raw: RawInfo,
}

Fields

machine_mode: MachineMode

The machine mode used to decode this instruction.

mnemonic: Mnemonic

The instruction-mnemonic.

length: u8

The length of the decoded instruction.

encoding: InstructionEncoding

The instruction-encoding.

opcode_map: OpcodeMap

The opcode map.

opcode: u8

The instruction opcode.

stack_width: u8

The stack width.

operand_width: u8

The effective operand width.

address_width: u8

The effective address width.

operand_count: u8

The number of instruction operands.

operand_count_visible: u8

The number of explicit (visible) instruction operands.

attributes: InstructionAttributes

Instruction attributes.

cpu_flags: &'static AccessedFlags<CpuFlag>

Information about CPU flags accessed by the instruction.

The bits in the masks correspond to the actual bits in the FLAGS/EFLAGS/RFLAGS register.

fpu_flags: &'static AccessedFlags<FpuFlag>

Information about FPU flags accessed by the instruction.

avx: AvxInfo

Extended information for AVX instructions.

meta: MetaInfo

Meta info.

raw: RawInfo

Detailed information about different instruction-parts.

Implementations

impl DecodedInstruction

pub fn calc_absolute_address( &self, address: u64, operand: &DecodedOperand ) -> Result<u64>

Calculates the absolute address for the given instruction operand, using the given address as the address for this instruction.

pub fn calc_absolute_address_ex( &self, address: u64, operand: &DecodedOperand, context: &RegisterContext ) -> Result<u64>

Behaves like calc_absolute_address, but takes runtime-known values of registers passed in the context into account.

Trait Implementations

impl Clone for DecodedInstruction

fn clone(&self) -> DecodedInstruction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DecodedInstruction

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

Formats the value using the given formatter.

impl Hash for DecodedInstruction

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 DecodedInstruction

fn eq(&self, other: &DecodedInstruction) -> 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 Serialize for DecodedInstruction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DecodedInstruction

impl StructuralPartialEq for DecodedInstruction