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 operands: [DecodedOperand; 10],
    pub attributes: InstructionAttributes,
    pub accessed_flags: [CPUFlagAction; 21],
    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 instruciton-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.

operands: [DecodedOperand; 10]

Detailed information for all instruction operands.

attributes: InstructionAttributes

Instruction attributes.

accessed_flags: [CPUFlagAction; 21]

The action performed to the CPUFlag used to index this array.

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.

pub fn get_flags(&self, action: CPUFlagAction) -> Result<CPUFlag>

Returns a mask of CPU-flags that match the given action.

pub fn get_flags_read(&self) -> Result<CPUFlag>

Returns a mask of CPU-flags that are read (tested) by this instruction.

pub fn get_flags_written(&self) -> Result<CPUFlag>

Returns a mask of CPU-flags that are written (modified, undefined) by this instruction.

pub fn get_segments(&self) -> Result<InstructionSegments>

Returns offsets and sizes of all logical instruction segments.

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 Eq for DecodedInstruction

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, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<DecodedInstruction> 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: &DecodedInstruction) -> bool

This method tests for !=.

impl StructuralEq for DecodedInstruction

impl StructuralPartialEq for DecodedInstruction