Struct iced_x86::Instruction

source ·

pub struct Instruction { /* private fields */ }

Expand description

A 16/32/64-bit x86 instruction. Created by Decoder, by CodeAssembler or by Instruction::with*() methods.

Implementations§

source §

impl Instruction

source

pub fn new() -> Self

Creates an empty Instruction (all fields are cleared). See also the with_*() constructor methods.

source

pub fn eq_all_bits(&self, other: &Self) -> bool

Checks if two instructions are equal, comparing all bits, not ignoring anything. == ignores some fields.

source

pub const fn ip16(&self) -> u16

Gets the 16-bit IP of the instruction, see also next_ip16()

source

pub fn set_ip16(&mut self, new_value: u16)

Sets the 16-bit IP of the instruction, see also set_next_ip16()

pub const fn ip32(&self) -> u32

Gets the 32-bit IP of the instruction, see also next_ip32()

source

pub fn set_ip32(&mut self, new_value: u32)

Sets the 32-bit IP of the instruction, see also set_next_ip32()

pub const fn ip(&self) -> u64

Gets the 64-bit IP of the instruction, see also next_ip()

source

pub fn set_ip(&mut self, new_value: u64)

Sets the 64-bit IP of the instruction, see also set_next_ip()

pub const fn next_ip16(&self) -> u16

Gets the 16-bit IP of the next instruction, see also ip16()

source

pub fn set_next_ip16(&mut self, new_value: u16)

Sets the 16-bit IP of the next instruction, see also set_ip16()

pub const fn next_ip32(&self) -> u32

Gets the 32-bit IP of the next instruction, see also ip32()

source

pub fn set_next_ip32(&mut self, new_value: u32)

Sets the 32-bit IP of the next instruction, see also set_ip32()

pub const fn next_ip(&self) -> u64

Gets the 64-bit IP of the next instruction, see also ip()

source

pub fn set_next_ip(&mut self, new_value: u64)

Sets the 64-bit IP of the next instruction, see also set_ip()

pub fn code_size(&self) -> CodeSize

Gets the code size when the instruction was decoded. This value is informational and can be used by a formatter.

source

pub fn set_code_size(&mut self, new_value: CodeSize)

Sets the code size when the instruction was decoded. This value is informational and can be used by a formatter.

pub fn is_invalid(&self) -> bool

Checks if it’s an invalid instruction (code() == Code::INVALID)

source

pub const fn code(&self) -> Code

Gets the instruction code, see also mnemonic()

source

pub fn set_code(&mut self, new_value: Code)

Sets the instruction code

pub fn mnemonic(&self) -> Mnemonic

Gets the mnemonic, see also code()

source

pub fn op_count(&self) -> u32

Gets the operand count. An instruction can have 0-5 operands.

pub const fn len(&self) -> usize

Gets the length of the instruction, 0-15 bytes. This is just informational. If you modify the instruction or create a new one, this method could return the wrong value.

source

pub fn set_len(&mut self, new_value: usize)

Sets the length of the instruction, 0-15 bytes. This is just informational. If you modify the instruction or create a new one, this method could return the wrong value.

pub fn has_xacquire_prefix(&self) -> bool

true if the instruction has the XACQUIRE prefix (F2)

source

pub fn set_has_xacquire_prefix(&mut self, new_value: bool)

true if the instruction has the XACQUIRE prefix (F2)

pub fn has_xrelease_prefix(&self) -> bool

true if the instruction has the XRELEASE prefix (F3)

source

pub fn set_has_xrelease_prefix(&mut self, new_value: bool)

true if the instruction has the XRELEASE prefix (F3)

pub const fn has_rep_prefix(&self) -> bool

true if the instruction has the REPE or REP prefix (F3)

source

pub fn set_has_rep_prefix(&mut self, new_value: bool)

true if the instruction has the REPE or REP prefix (F3)

pub const fn has_repe_prefix(&self) -> bool

true if the instruction has the REPE or REP prefix (F3)

source

pub fn set_has_repe_prefix(&mut self, new_value: bool)

true if the instruction has the REPE or REP prefix (F3)

pub const fn has_repne_prefix(&self) -> bool

true if the instruction has the REPNE prefix (F2)

source

pub fn set_has_repne_prefix(&mut self, new_value: bool)

true if the instruction has the REPNE prefix (F2)

pub const fn has_lock_prefix(&self) -> bool

true if the instruction has the LOCK prefix (F0)

source

pub fn set_has_lock_prefix(&mut self, new_value: bool)

true if the instruction has the LOCK prefix (F0)

pub const fn op0_kind(&self) -> OpKind

Gets operand #0’s kind if the operand exists (see op_count() and try_op_kind())

source

pub fn set_op0_kind(&mut self, new_value: OpKind)

Sets operand #0’s kind if the operand exists (see op_count() and try_set_op_kind())

pub const fn op1_kind(&self) -> OpKind

Gets operand #1’s kind if the operand exists (see op_count() and try_op_kind())

source

pub fn set_op1_kind(&mut self, new_value: OpKind)

Sets operand #1’s kind if the operand exists (see op_count() and try_set_op_kind())

pub const fn op2_kind(&self) -> OpKind

Gets operand #2’s kind if the operand exists (see op_count() and try_op_kind())

source

pub fn set_op2_kind(&mut self, new_value: OpKind)

Sets operand #2’s kind if the operand exists (see op_count() and try_set_op_kind())

pub const fn op3_kind(&self) -> OpKind

Gets operand #3’s kind if the operand exists (see op_count() and try_op_kind())

source

pub fn set_op3_kind(&mut self, new_value: OpKind)

Sets operand #3’s kind if the operand exists (see op_count() and try_set_op_kind())

pub const fn op4_kind(&self) -> OpKind

Gets operand #4’s kind if the operand exists (see op_count() and try_op_kind())

source

pub fn set_op4_kind(&mut self, new_value: OpKind)

Sets operand #4’s kind if the operand exists (see op_count() and try_set_op_kind())

pub fn op_kinds( &self ) -> impl Iterator<Item = OpKind> + ExactSizeIterator + FusedIterator

Gets all op kinds (op_count() values)

pub fn op_kind(&self, operand: u32) -> OpKind

Gets an operand’s kind if it exists (see op_count())

pub fn set_op_kind(&mut self, operand: u32, op_kind: OpKind)

Sets an operand’s kind

Arguments

operand: Operand number, 0-4
op_kind: Operand kind

source

pub const fn has_segment_prefix(&self) -> bool

Checks if the instruction has a segment override prefix, see segment_prefix()

source

pub fn segment_prefix(&self) -> Register

Gets the segment override prefix or Register::None if none. See also memory_segment(). Use this method if the operand has kind OpKind::Memory, OpKind::MemorySegSI, OpKind::MemorySegESI, OpKind::MemorySegRSI

source

pub fn set_segment_prefix(&mut self, new_value: Register)

Sets the segment override prefix or Register::None if none. See also memory_segment(). Use this method if the operand has kind OpKind::Memory, OpKind::MemorySegSI, OpKind::MemorySegESI, OpKind::MemorySegRSI

Arguments

new_value: Segment register prefix

source

pub fn memory_segment(&self) -> Register

Gets the effective segment register used to reference the memory location. Use this method if the operand has kind OpKind::Memory, OpKind::MemorySegSI, OpKind::MemorySegESI, OpKind::MemorySegRSI

source

pub const fn memory_displ_size(&self) -> u32

Gets the size of the memory displacement in bytes. Valid values are 0, 1 (16/32/64-bit), 2 (16-bit), 4 (32-bit), 8 (64-bit). Note that the return value can be 1 and memory_displacement64() may still not fit in a signed byte if it’s an EVEX/MVEX encoded instruction. Use this method if the operand has kind OpKind::Memory

source

pub fn set_memory_displ_size(&mut self, new_value: u32)

Sets the size of the memory displacement in bytes. Valid values are 0, 1 (16/32/64-bit), 2 (16-bit), 4 (32-bit), 8 (64-bit). Note that the return value can be 1 and memory_displacement64() may still not fit in a signed byte if it’s an EVEX/MVEX encoded instruction. Use this method if the operand has kind OpKind::Memory

Arguments

new_value: Displacement size

source

pub const fn is_broadcast(&self) -> bool

true if the data is broadcast (EVEX instructions only)

source

pub fn set_is_broadcast(&mut self, new_value: bool)

Sets the is broadcast flag (EVEX instructions only)

Arguments

new_value: New value

source

pub fn memory_size(&self) -> MemorySize

Gets the size of the memory location that is referenced by the operand. See also is_broadcast(). Use this method if the operand has kind OpKind::Memory, OpKind::MemorySegSI, OpKind::MemorySegESI, OpKind::MemorySegRSI, OpKind::MemoryESDI, OpKind::MemoryESEDI, OpKind::MemoryESRDI

source

pub const fn memory_index_scale(&self) -> u32

Gets the index register scale value, valid values are *1, *2, *4, *8. Use this method if the operand has kind OpKind::Memory

source

pub fn set_memory_index_scale(&mut self, new_value: u32)

Sets the index register scale value, valid values are *1, *2, *4, *8. Use this method if the operand has kind OpKind::Memory

Arguments

new_value: New value (1, 2, 4 or 8)

source

pub const fn memory_displacement32(&self) -> u32

Gets the memory operand’s displacement or the 32-bit absolute address if it’s an EIP or RIP relative memory operand. Use this method if the operand has kind OpKind::Memory

source

pub fn set_memory_displacement32(&mut self, new_value: u32)

Gets the memory operand’s displacement or the 32-bit absolute address if it’s an EIP or RIP relative memory operand. Use this method if the operand has kind OpKind::Memory

Arguments

new_value: New value

source

pub const fn memory_displacement64(&self) -> u64

Gets the memory operand’s displacement or the 64-bit absolute address if it’s an EIP or RIP relative memory operand. Use this method if the operand has kind OpKind::Memory

source

pub fn set_memory_displacement64(&mut self, new_value: u64)

Gets the memory operand’s displacement or the 64-bit absolute address if it’s an EIP or RIP relative memory operand. Use this method if the operand has kind OpKind::Memory

Arguments

new_value: New value

source

pub fn immediate(&self, operand: u32) -> u64

Gets an operand’s immediate value

Arguments

operand: Operand number, 0-4

source

pub fn set_immediate_i32(&mut self, operand: u32, new_value: i32)

Sets an operand’s immediate value

Arguments

operand: Operand number, 0-4
new_value: Immediate

source

pub fn set_immediate_u32(&mut self, operand: u32, new_value: u32)

Sets an operand’s immediate value

Arguments

operand: Operand number, 0-4
new_value: Immediate

source

pub fn set_immediate_i64(&mut self, operand: u32, new_value: i64)

Sets an operand’s immediate value

Arguments

operand: Operand number, 0-4
new_value: Immediate

source

pub fn set_immediate_u64(&mut self, operand: u32, new_value: u64)

Sets an operand’s immediate value

Arguments

operand: Operand number, 0-4
new_value: Immediate

source

pub const fn immediate8(&self) -> u8

Gets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8

source

pub fn set_immediate8(&mut self, new_value: u8)

Sets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8

Arguments

new_value: New value

source

pub const fn immediate8_2nd(&self) -> u8

Gets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8_2nd

source

pub fn set_immediate8_2nd(&mut self, new_value: u8)

Sets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8_2nd

Arguments

new_value: New value

source

pub const fn immediate16(&self) -> u16

Gets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate16

source

pub fn set_immediate16(&mut self, new_value: u16)

Sets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate16

Arguments

new_value: New value

source

pub const fn immediate32(&self) -> u32

Gets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate32

source

pub fn set_immediate32(&mut self, new_value: u32)

Sets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate32

Arguments

new_value: New value

source

pub const fn immediate64(&self) -> u64

Gets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate64

source

pub fn set_immediate64(&mut self, new_value: u64)

Sets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate64

Arguments

new_value: New value

source

pub const fn immediate8to16(&self) -> i16

Gets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8to16

source

pub fn set_immediate8to16(&mut self, new_value: i16)

Sets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8to16

Arguments

new_value: New value

source

pub const fn immediate8to32(&self) -> i32

Gets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8to32

source

pub fn set_immediate8to32(&mut self, new_value: i32)

Sets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8to32

Arguments

new_value: New value

source

pub const fn immediate8to64(&self) -> i64

Gets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8to64

source

pub fn set_immediate8to64(&mut self, new_value: i64)

Sets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate8to64

Arguments

new_value: New value

source

pub const fn immediate32to64(&self) -> i64

Gets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate32to64

source

pub fn set_immediate32to64(&mut self, new_value: i64)

Sets the operand’s immediate value. Use this method if the operand has kind OpKind::Immediate32to64

Arguments

new_value: New value

source

pub const fn near_branch16(&self) -> u16

Gets the operand’s branch target. Use this method if the operand has kind OpKind::NearBranch16

source

pub fn set_near_branch16(&mut self, new_value: u16)

Sets the operand’s branch target. Use this method if the operand has kind OpKind::NearBranch16

Arguments

new_value: New value

source

pub const fn near_branch32(&self) -> u32

Gets the operand’s branch target. Use this method if the operand has kind OpKind::NearBranch32

source

pub fn set_near_branch32(&mut self, new_value: u32)

Sets the operand’s branch target. Use this method if the operand has kind OpKind::NearBranch32

Arguments

new_value: New value

source

pub const fn near_branch64(&self) -> u64

Gets the operand’s branch target. Use this method if the operand has kind OpKind::NearBranch64

source

pub fn set_near_branch64(&mut self, new_value: u64)

Sets the operand’s branch target. Use this method if the operand has kind OpKind::NearBranch64

Arguments

new_value: New value

source

pub fn near_branch_target(&self) -> u64

Gets the near branch target if it’s a CALL/JMP/Jcc near branch instruction (i.e., if op0_kind() is OpKind::NearBranch16, OpKind::NearBranch32 or OpKind::NearBranch64)

source

pub const fn far_branch16(&self) -> u16

Gets the operand’s branch target. Use this method if the operand has kind OpKind::FarBranch16

source

pub fn set_far_branch16(&mut self, new_value: u16)

Sets the operand’s branch target. Use this method if the operand has kind OpKind::FarBranch16

Arguments

new_value: New value

source

pub const fn far_branch32(&self) -> u32

Gets the operand’s branch target. Use this method if the operand has kind OpKind::FarBranch32

source

pub fn set_far_branch32(&mut self, new_value: u32)

Sets the operand’s branch target. Use this method if the operand has kind OpKind::FarBranch32

Arguments

new_value: New value

source

pub const fn far_branch_selector(&self) -> u16

Gets the operand’s branch target selector. Use this method if the operand has kind OpKind::FarBranch16 or OpKind::FarBranch32

source

pub fn set_far_branch_selector(&mut self, new_value: u16)

Sets the operand’s branch target selector. Use this method if the operand has kind OpKind::FarBranch16 or OpKind::FarBranch32

Arguments

new_value: New value

source

pub const fn memory_base(&self) -> Register

Gets the memory operand’s base register or Register::None if none. Use this method if the operand has kind OpKind::Memory

source

pub fn set_memory_base(&mut self, new_value: Register)

Sets the memory operand’s base register or Register::None if none. Use this method if the operand has kind OpKind::Memory

Arguments

new_value: New value

source

pub const fn memory_index(&self) -> Register

Gets the memory operand’s index register or Register::None if none. Use this method if the operand has kind OpKind::Memory

source

pub fn set_memory_index(&mut self, new_value: Register)

Sets the memory operand’s index register or Register::None if none. Use this method if the operand has kind OpKind::Memory

Arguments

new_value: New value

source

pub const fn op0_register(&self) -> Register

Gets operand #0’s register value. Use this method if operand #0 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

source

pub fn set_op0_register(&mut self, new_value: Register)

Sets operand #0’s register value. Use this method if operand #0 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

Arguments

new_value: New value

source

pub const fn op1_register(&self) -> Register

Gets operand #1’s register value. Use this method if operand #1 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

source

pub fn set_op1_register(&mut self, new_value: Register)

Sets operand #1’s register value. Use this method if operand #1 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

Arguments

new_value: New value

source

pub const fn op2_register(&self) -> Register

Gets operand #2’s register value. Use this method if operand #2 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

source

pub fn set_op2_register(&mut self, new_value: Register)

Sets operand #2’s register value. Use this method if operand #2 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

Arguments

new_value: New value

source

pub const fn op3_register(&self) -> Register

Gets operand #3’s register value. Use this method if operand #3 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

source

pub fn set_op3_register(&mut self, new_value: Register)

Sets operand #3’s register value. Use this method if operand #3 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

Arguments

new_value: New value

source

pub const fn op4_register(&self) -> Register

Gets operand #4’s register value. Use this method if operand #4 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

source

pub fn set_op4_register(&mut self, new_value: Register)

Sets operand #4’s register value. Use this method if operand #4 (op0_kind()) has kind OpKind::Register, see op_count() and try_op_register()

Arguments

new_value: New value

source

pub fn op_register(&self, operand: u32) -> Register

Gets the operand’s register value. Use this method if the operand has kind OpKind::Register

Arguments

operand: Operand number, 0-4

Examples

use iced_x86::*;

// add [rax],ebx
let bytes = b"\x01\x18";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
let instr = decoder.decode();

assert_eq!(instr.op_count(), 2);
assert_eq!(instr.op_kind(0), OpKind::Memory);
assert_eq!(instr.op_kind(1), OpKind::Register);
assert_eq!(instr.op_register(1), Register::EBX);

source

pub fn set_op_register(&mut self, operand: u32, new_value: Register)

Sets the operand’s register value. Use this method if the operand has kind OpKind::Register

Arguments

operand: Operand number, 0-4
new_value: New value

source

pub fn op_mask(&self) -> Register

Gets the opmask register (Register::K1 - Register::K7) or Register::None if none

source

pub fn set_op_mask(&mut self, new_value: Register)

Sets the opmask register (Register::K1 - Register::K7) or Register::None if none

Arguments

new_value: New value

source

pub const fn has_op_mask(&self) -> bool

Checks if there’s an opmask register (op_mask())

source

pub const fn zeroing_masking(&self) -> bool

true if zeroing-masking, false if merging-masking. Only used by most EVEX encoded instructions that use opmask registers.

source

pub fn set_zeroing_masking(&mut self, new_value: bool)

true if zeroing-masking, false if merging-masking. Only used by most EVEX encoded instructions that use opmask registers.

Arguments

new_value: New value

source

pub const fn merging_masking(&self) -> bool

true if merging-masking, false if zeroing-masking. Only used by most EVEX encoded instructions that use opmask registers.

source

pub fn set_merging_masking(&mut self, new_value: bool)

true if merging-masking, false if zeroing-masking. Only used by most EVEX encoded instructions that use opmask registers.

Arguments

new_value: New value

source

pub fn rounding_control(&self) -> RoundingControl

Gets the rounding control (SAE is implied but suppress_all_exceptions() still returns false) or RoundingControl::None if the instruction doesn’t use it.

source

pub fn set_rounding_control(&mut self, new_value: RoundingControl)

Sets the rounding control (SAE is implied but suppress_all_exceptions() still returns false) or RoundingControl::None if the instruction doesn’t use it.

Arguments

new_value: New value

source

pub const fn declare_data_len(&self) -> usize

Gets the number of elements in a db/dw/dd/dq directive. Can only be called if code() is Code::DeclareByte, Code::DeclareWord, Code::DeclareDword, Code::DeclareQword

source

pub fn set_declare_data_len(&mut self, new_value: usize)

Sets the number of elements in a db/dw/dd/dq directive. Can only be called if code() is Code::DeclareByte, Code::DeclareWord, Code::DeclareDword, Code::DeclareQword

Arguments

new_value: New value: db: 1-16; dw: 1-8; dd: 1-4; dq: 1-2

source

pub fn set_declare_byte_value_i8(&mut self, index: usize, new_value: i8)

Sets a new db value, see also declare_data_len(). Can only be called if code() is Code::DeclareByte

Arguments

index: Index (0-15)
new_value: New value

source

pub fn try_set_declare_byte_value_i8( &mut self, index: usize, new_value: i8 ) -> Result<(), IcedError>

Sets a new db value, see also declare_data_len(). Can only be called if code() is Code::DeclareByte

Errors

Fails if index is invalid

Arguments

index: Index (0-15)
new_value: New value

source

pub fn set_declare_byte_value(&mut self, index: usize, new_value: u8)

Sets a new db value, see also declare_data_len(). Can only be called if code() is Code::DeclareByte

Arguments

index: Index (0-15)
new_value: New value

source

pub fn get_declare_byte_value(&self, index: usize) -> u8

Gets a db value, see also declare_data_len(). Can only be called if code() is Code::DeclareByte

Arguments

index: Index (0-15)

source

pub fn set_declare_word_value_i16(&mut self, index: usize, new_value: i16)

Sets a new dw value, see also declare_data_len(). Can only be called if code() is Code::DeclareWord

Arguments

index: Index (0-7)
new_value: New value

source

pub fn set_declare_word_value(&mut self, index: usize, new_value: u16)

Sets a new dw value, see also declare_data_len(). Can only be called if code() is Code::DeclareWord

Arguments

index: Index (0-7)
new_value: New value

source

pub fn get_declare_word_value(&self, index: usize) -> u16

Gets a dw value, see also declare_data_len(). Can only be called if code() is Code::DeclareWord

Arguments

index: Index (0-7)

source

pub fn set_declare_dword_value_i32(&mut self, index: usize, new_value: i32)

Sets a new dd value, see also declare_data_len(). Can only be called if code() is Code::DeclareDword

Arguments

index: Index (0-3)
new_value: New value

source

pub fn set_declare_dword_value(&mut self, index: usize, new_value: u32)

Sets a new dd value, see also declare_data_len(). Can only be called if code() is Code::DeclareDword

Arguments

index: Index (0-3)
new_value: New value

source

pub fn get_declare_dword_value(&self, index: usize) -> u32

Gets a dd value, see also declare_data_len(). Can only be called if code() is Code::DeclareDword

Arguments

index: Index (0-3)

source

pub fn set_declare_qword_value_i64(&mut self, index: usize, new_value: i64)

Sets a new dq value, see also declare_data_len(). Can only be called if code() is Code::DeclareQword

Arguments

index: Index (0-1)
new_value: New value

source

pub fn set_declare_qword_value(&mut self, index: usize, new_value: u64)

Sets a new dq value, see also declare_data_len(). Can only be called if code() is Code::DeclareQword

Arguments

index: Index (0-1)
new_value: New value

source

pub fn get_declare_qword_value(&self, index: usize) -> u64

Gets a dq value, see also declare_data_len(). Can only be called if code() is Code::DeclareQword

Arguments

index: Index (0-1)

source

pub const fn is_vsib(&self) -> bool

Checks if this is a VSIB instruction, see also is_vsib32(), is_vsib64()

source

pub const fn is_vsib32(&self) -> bool

VSIB instructions only (is_vsib()): true if it’s using 32-bit indexes, false if it’s using 64-bit indexes

source

pub const fn is_vsib64(&self) -> bool

VSIB instructions only (is_vsib()): true if it’s using 64-bit indexes, false if it’s using 32-bit indexes

source

pub const fn vsib(&self) -> Option<bool>

Checks if it’s a vsib instruction.

Returns

Some(true) if it’s a VSIB instruction with 64-bit indexes
Some(false) if it’s a VSIB instruction with 32-bit indexes
None if it’s not a VSIB instruction.

source

pub const fn suppress_all_exceptions(&self) -> bool

Gets the suppress all exceptions flag (EVEX/MVEX encoded instructions). Note that if rounding_control() is not RoundingControl::None, SAE is implied but this method will still return false.

source

pub fn set_suppress_all_exceptions(&mut self, new_value: bool)

Sets the suppress all exceptions flag (EVEX/MVEX encoded instructions). Note that if rounding_control() is not RoundingControl::None, SAE is implied but this method will still return false.

Arguments

new_value: New value

source

pub fn is_ip_rel_memory_operand(&self) -> bool

Checks if the memory operand is RIP/EIP relative

source

pub fn ip_rel_memory_address(&self) -> u64

Gets the RIP/EIP releative address (memory_displacement32() or memory_displacement64()). This method is only valid if there’s a memory operand with RIP/EIP relative addressing, see is_ip_rel_memory_operand()

source

pub fn virtual_address<F>( &self, operand: u32, element_index: usize, get_register_value: F ) -> Option<u64>where F: FnMut(Register, usize, usize) -> Option<u64>,

Gets the virtual address of a memory operand

Arguments

operand: Operand number, 0-4, must be a memory operand
element_index: Only used if it’s a vsib memory operand. This is the element index of the vector index register.
get_register_value: Function that returns the value of a register or the base address of a segment register, or None for unsupported registers.

Call-back function args

Arg 1: register: Register (GPR8, GPR16, GPR32, GPR64, XMM, YMM, ZMM, seg). If it’s a segment register, the call-back function should return the segment’s base address, not the segment’s register value.
Arg 2: element_index: Only used if it’s a vsib memory operand. This is the element index of the vector index register.
Arg 3: element_size: Only used if it’s a vsib memory operand. Size in bytes of elements in vector index register (4 or 8).

Examples

use iced_x86::*;

// add [rdi+r12*8-5AA5EDCCh],esi
let bytes = b"\x42\x01\xB4\xE7\x34\x12\x5A\xA5";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
let instr = decoder.decode();

let va = instr.virtual_address(0, 0, |register, _element_index, _element_size| {
    match register {
        // The base address of ES, CS, SS and DS is always 0 in 64-bit mode
        Register::DS => Some(0x0000_0000_0000_0000),
        Register::RDI => Some(0x0000_0000_1000_0000),
        Register::R12 => Some(0x0000_0004_0000_0000),
        _ => None,
    }
});
assert_eq!(va, Some(0x0000_001F_B55A_1234));