Struct iced_x86::Instruction

pub struct Instruction { /* fields omitted */ }

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

Implementations

impl Instruction

pub fn new() -> Self

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

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

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

pub fn ip16(&self) -> u16

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

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

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

Arguments

• new_value: new value

pub fn ip32(&self) -> u32

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

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

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

Arguments

• new_value: new value

pub fn ip(&self) -> u64

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

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

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

Arguments

• new_value: new value

pub fn next_ip16(&self) -> u16

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

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

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

Arguments

• new_value: new value

pub fn next_ip32(&self) -> u32

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

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

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

Arguments

• new_value: new value

pub fn next_ip(&self) -> u64

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

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

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

Arguments

• new_value: new value

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.

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.

Arguments

• new_value: new value

pub fn is_invalid(&self) -> bool

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

pub fn code(&self) -> Code

Gets the instruction code, see also mnemonic()

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

Sets the instruction code

Arguments

• new_value: new value

pub fn mnemonic(&self) -> Mnemonic

Gets the mnemonic, see also code()

pub fn op_count(&self) -> u32

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

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);

pub 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.

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.

Arguments

• new_value: new value

pub fn has_xacquire_prefix(&self) -> bool

true if the instruction has the XACQUIRE prefix (F2)

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

true if the instruction has the XACQUIRE prefix (F2)

Arguments

• new_value: new value

pub fn has_xrelease_prefix(&self) -> bool

true if the instruction has the XRELEASE prefix (F3)

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

true if the instruction has the XRELEASE prefix (F3)

Arguments

• new_value: new value

pub fn has_rep_prefix(&self) -> bool

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

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

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

Arguments

• new_value: new value

pub fn has_repe_prefix(&self) -> bool

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

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

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

Arguments

• new_value: new value

pub fn has_repne_prefix(&self) -> bool

true if the instruction has the REPNE prefix (F2)

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

true if the instruction has the REPNE prefix (F2)

Arguments

• new_value: new value

pub fn has_lock_prefix(&self) -> bool

true if the instruction has the LOCK prefix (F0)

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

true if the instruction has the LOCK prefix (F0)

Arguments

• new_value: new value

pub fn op0_kind(&self) -> OpKind

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

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())

Arguments

• new_value: new value

pub fn op1_kind(&self) -> OpKind

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

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())

Arguments

• new_value: new value

pub fn op2_kind(&self) -> OpKind

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

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())

Arguments

• new_value: new value

pub fn op3_kind(&self) -> OpKind

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

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())

Arguments

• new_value: new value

pub fn op4_kind(&self) -> OpKind

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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_op4_kind() instead

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

Panics

Panics if new_value is invalid.

Arguments

• new_value: new value

pub fn try_set_op4_kind(&mut self, new_value: OpKind) -> Result<(), IcedError>

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

Errors

Fails if new_value is invalid.

Arguments

• new_value: new value

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

Gets all op kinds (op_count() values)

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();

for (i, op_kind) in instr.op_kinds().enumerate() {
    println!("op kind #{} = {:?}", i, op_kind);
}

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

👎 Deprecated since 1.10.0:

This method can panic, use try_op_kind() instead

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

Panics

Panics if operand is invalid

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.memory_base(), Register::RAX);
assert_eq!(instr.memory_index(), Register::None);
assert_eq!(instr.op_kind(1), OpKind::Register);
assert_eq!(instr.op_register(1), Register::EBX);

pub fn try_op_kind(&self, operand: u32) -> Result<OpKind, IcedError>

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

Errors

Fails if operand is invalid

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.try_op_kind(0).unwrap(), OpKind::Memory);
assert_eq!(instr.memory_base(), Register::RAX);
assert_eq!(instr.memory_index(), Register::None);
assert_eq!(instr.try_op_kind(1).unwrap(), OpKind::Register);
assert_eq!(instr.op_register(1), Register::EBX);

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_op_kind() instead

Sets an operand’s kind

Panics

Panics if operand or op_kind is invalid

Arguments

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

pub fn try_set_op_kind(
    &mut self,
    operand: u32,
    op_kind: OpKind
) -> Result<(), IcedError>

Sets an operand’s kind

Errors

Fails if operand or op_kind is invalid

Arguments

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

pub fn has_segment_prefix(&self) -> bool

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

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

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

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

pub 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 encoded instruction. Use this method if the operand has kind OpKind::Memory

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 encoded instruction. Use this method if the operand has kind OpKind::Memory

Arguments

• new_value: Displacement size

pub fn is_broadcast(&self) -> bool

true if the data is broadcasted (EVEX instructions only)

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

Sets the is broadcast flag (EVEX instructions only)

Arguments

• new_value: New value

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

pub 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

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)

pub fn memory_displacement(&self) -> u32

👎 Deprecated since 1.11.0:

Use memory_displacement32() or memory_displacement64() instead

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

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

👎 Deprecated since 1.11.0:

Use set_memory_displacement32() or set_memory_displacement64() instead

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

pub 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

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

pub 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

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

pub fn try_immediate(&self, operand: u32) -> Result<u64, IcedError>

Gets an operand’s immediate value, or None if the operand is not immediate

Errors

Fails if operand is invalid or not an immediate operand

Arguments

• operand: Operand number, 0-4

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

👎 Deprecated since 1.11.0:

This method can panic, use try_immediate() instead

Gets an operand’s immediate value

Panics

Panics if operand is invalid or not immediate.

Arguments

• operand: Operand number, 0-4

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_immediate_i32() instead

Sets an operand’s immediate value

Panics

Panics if operand is invalid or if it’s not an immediate operand

Arguments

• operand: Operand number, 0-4
• new_value: Immediate

pub fn try_set_immediate_i32(
    &mut self,
    operand: u32,
    new_value: i32
) -> Result<(), IcedError>

Sets an operand’s immediate value

Errors

Fails if operand is invalid or if it’s not an immediate operand

Arguments

• operand: Operand number, 0-4
• new_value: Immediate

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_immediate_u32() instead

Sets an operand’s immediate value

Panics

Panics if operand is invalid or if it’s not an immediate operand

Arguments

• operand: Operand number, 0-4
• new_value: Immediate

pub fn try_set_immediate_u32(
    &mut self,
    operand: u32,
    new_value: u32
) -> Result<(), IcedError>

Sets an operand’s immediate value

Errors

Fails if operand is invalid or if it’s not an immediate operand

Arguments

• operand: Operand number, 0-4
• new_value: Immediate

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_immediate_i64() instead

Sets an operand’s immediate value

Panics

Panics if operand is invalid or if it’s not an immediate operand

Arguments

• operand: Operand number, 0-4
• new_value: Immediate

pub fn try_set_immediate_i64(
    &mut self,
    operand: u32,
    new_value: i64
) -> Result<(), IcedError>

Sets an operand’s immediate value

Errors

Fails if operand is invalid or if it’s not an immediate operand

Arguments

• operand: Operand number, 0-4
• new_value: Immediate

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_immediate_u64() instead

Sets an operand’s immediate value

Panics

Panics if operand is invalid or if it’s not an immediate operand

Arguments

• operand: Operand number, 0-4
• new_value: Immediate

pub fn try_set_immediate_u64(
    &mut self,
    operand: u32,
    new_value: u64
) -> Result<(), IcedError>

Sets an operand’s immediate value

Errors

Fails if operand is invalid or if it’s not an immediate operand

Arguments

• operand: Operand number, 0-4
• new_value: Immediate

pub fn immediate8(&self) -> u8

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

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

pub fn immediate8_2nd(&self) -> u8

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

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

pub fn immediate16(&self) -> u16

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

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

pub fn immediate32(&self) -> u32

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

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

pub fn immediate64(&self) -> u64

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

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

pub fn immediate8to16(&self) -> i16

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

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

pub fn immediate8to32(&self) -> i32

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

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

pub fn immediate8to64(&self) -> i64

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

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

pub fn immediate32to64(&self) -> i64

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

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

pub fn memory_address64(&self) -> u64

👎 Deprecated since 1.11.0:

OpKind::Memory64 is deprecated, this method does nothing now. Use memory_displacement64() instead.

OpKind::Memory64 is deprecated, this method does nothing now.

pub fn set_memory_address64(&mut self, _new_value: u64)

👎 Deprecated since 1.11.0:

OpKind::Memory64 is deprecated, this method does nothing now. Use set_memory_displacement64() instead.

OpKind::Memory64 is deprecated, this method does nothing now.

Arguments

• new_value: New value

pub fn near_branch16(&self) -> u16

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

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

pub fn near_branch32(&self) -> u32

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

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

pub fn near_branch64(&self) -> u64

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

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

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)

pub fn far_branch16(&self) -> u16

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

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

pub fn far_branch32(&self) -> u32

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

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

pub 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

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

pub 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

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

pub 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

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

pub 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()

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

pub 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()

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

pub 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()

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

pub 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()

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

pub 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()

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_op4_register() instead

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()

Panics

Panics if new_value is invalid

Arguments

• new_value: New value

pub fn try_set_op4_register(
    &mut self,
    new_value: Register
) -> Result<(), IcedError>

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()

Errors

Fails if new_value is invalid

Arguments

• new_value: New value

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

👎 Deprecated since 1.10.0:

This method can panic, use try_op_register() instead

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

Panics

Panics if operand is invalid

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);

pub fn try_op_register(&self, operand: u32) -> Result<Register, IcedError>

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

Errors

Fails if operand is invalid

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.try_op_register(1).unwrap(), Register::EBX);

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_op_register() instead

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

Panics

• Panics if operand is invalid
• Panics if new_value is invalid

Arguments

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

pub fn try_set_op_register(
    &mut self,
    operand: u32,
    new_value: Register
) -> Result<(), IcedError>

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

Errors

• Fails if operand is invalid
• Fails if new_value is invalid

Arguments

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

pub fn op_mask(&self) -> Register

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

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

pub fn has_op_mask(&self) -> bool

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

pub fn zeroing_masking(&self) -> bool

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

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

pub fn merging_masking(&self) -> bool

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

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

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.

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

pub 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

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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_declare_byte_value_i8() instead

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

Panics

• Panics if index is invalid

Arguments

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

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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_declare_byte_value() instead

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

Panics

• Panics if index is invalid

Arguments

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

pub fn try_set_declare_byte_value(
    &mut self,
    index: usize,
    new_value: u8
) -> 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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_get_declare_byte_value() instead

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

Panics

Panics if index is invalid

Arguments

• index: Index (0-15)

pub fn try_get_declare_byte_value(&self, index: usize) -> Result<u8, IcedError>

Gets a 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)

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_declare_word_value_i16() instead

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

Panics

• Panics if index is invalid

Arguments

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

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

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

Errors

• Fails if index is invalid

Arguments

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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_declare_word_value() instead

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

Panics

• Panics if index is invalid

Arguments

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

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

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

Errors

• Fails if index is invalid

Arguments

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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_get_declare_word_value() instead

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

Panics

Panics if index is invalid

Arguments

• index: Index (0-7)

pub fn try_get_declare_word_value(&self, index: usize) -> Result<u16, IcedError>

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

Errors

Fails if index is invalid

Arguments

• index: Index (0-7)

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_declare_dword_value_i32() instead

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

Panics

• Panics if index is invalid

Arguments

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

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

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

Errors

• Fails if index is invalid

Arguments

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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_declare_dword_value() instead

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

Panics

• Panics if index is invalid

Arguments

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

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

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

Errors

• Fails if index is invalid

Arguments

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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_get_declare_dword_value() instead

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

Panics

Panics if index is invalid

Arguments

• index: Index (0-3)

pub fn try_get_declare_dword_value(
    &self,
    index: usize
) -> Result<u32, IcedError>

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

Errors

Fails if index is invalid

Arguments

• index: Index (0-3)

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_declare_qword_value_i64() instead

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

Panics

• Panics if index is invalid

Arguments

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

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

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

Errors

• Fails if index is invalid

Arguments

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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_set_declare_qword_value() instead

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

Panics

• Panics if index is invalid

Arguments

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

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

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

Errors

• Fails if index is invalid

Arguments

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

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

👎 Deprecated since 1.10.0:

This method can panic, use try_get_declare_qword_value() instead

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

Panics

Panics if index is invalid

Arguments

• index: Index (0-1)

pub fn try_get_declare_qword_value(
    &self,
    index: usize
) -> Result<u64, IcedError>

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

Errors

Fails if index is invalid

Arguments

• index: Index (0-1)

pub fn is_vsib(&self) -> bool

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

pub 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

pub 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

pub 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.

pub fn suppress_all_exceptions(&self) -> bool

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

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

Sets the suppress all exceptions flag (EVEX 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

pub fn is_ip_rel_memory_operand(&self) -> bool

Checks if the memory operand is RIP/EIP relative

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()

pub fn try_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.try_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));

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

👎 Deprecated since 1.11.0:

This method can panic, use try_virtual_address() instead

Gets the virtual address of a memory operand. See also try_virtual_address()

Panics

Panics if operand is invalid

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.

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 => 0x0000_0000_0000_0000,
        Register::RDI => 0x0000_0000_1000_0000,
        Register::R12 => 0x0000_0004_0000_0000,
        _ => unimplemented!(),
    }
});
assert_eq!(va, 0x0000_001F_B55A_1234);

impl Instruction

pub fn stack_pointer_increment(&self) -> i32

Gets the number of bytes added to SP/ESP/RSP or 0 if it’s not an instruction that pushes or pops data. This method assumes the instruction doesn’t change the privilege level (eg. IRET/D/Q). If it’s the LEAVE instruction, this method returns 0.

Examples

use iced_x86::*;

// pushfq
let bytes = b"\x9C";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
let instr = decoder.decode();

assert!(instr.is_stack_instruction());
assert_eq!(instr.stack_pointer_increment(), -8);

pub fn fpu_stack_increment_info(&self) -> FpuStackIncrementInfo

Gets the FPU status word’s TOP increment and whether it’s a conditional or unconditional push/pop and whether TOP is written.

Examples

use iced_x86::*;

// ficomp dword ptr [rax]
let bytes = b"\xDA\x18";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
let instr = decoder.decode();

let info = instr.fpu_stack_increment_info();
// It pops the stack once
assert_eq!(info.increment(), 1);
assert!(!info.conditional());
assert!(info.writes_top());

pub fn encoding(&self) -> EncodingKind

Instruction encoding, eg. Legacy, 3DNow!, VEX, EVEX, XOP

Examples

use iced_x86::*;

// vmovaps xmm1,xmm5
let bytes = b"\xC5\xF8\x28\xCD";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);
let instr = decoder.decode();

assert_eq!(instr.encoding(), EncodingKind::VEX);

pub fn cpuid_features(&self) -> &'static [CpuidFeature]

Gets the CPU or CPUID feature flags

Examples

use iced_x86::*;

// vmovaps xmm1,xmm5
// vmovaps xmm10{k3}{z},xmm19
let bytes = b"\xC5\xF8\x28\xCD\x62\x31\x7C\x8B\x28\xD3";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// vmovaps xmm1,xmm5
let instr = decoder.decode();
let cpuid = instr.cpuid_features();
assert_eq!(cpuid.len(), 1);
assert_eq!(cpuid[0], CpuidFeature::AVX);

// vmovaps xmm10{k3}{z},xmm19
let instr = decoder.decode();
let cpuid = instr.cpuid_features();
assert_eq!(cpuid.len(), 2);
assert_eq!(cpuid[0], CpuidFeature::AVX512VL);
assert_eq!(cpuid[1], CpuidFeature::AVX512F);

pub fn flow_control(&self) -> FlowControl

Control flow info

Examples

use iced_x86::*;

// or ecx,esi
// ud0 rcx,rsi
// call rcx
let bytes = b"\x0B\xCE\x48\x0F\xFF\xCE\xFF\xD1";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// or ecx,esi
let instr = decoder.decode();
assert_eq!(instr.flow_control(), FlowControl::Next);

// ud0 rcx,rsi
let instr = decoder.decode();
assert_eq!(instr.flow_control(), FlowControl::Exception);

// call rcx
let instr = decoder.decode();
assert_eq!(instr.flow_control(), FlowControl::IndirectCall);

pub fn is_privileged(&self) -> bool

true if it’s a privileged instruction (all CPL=0 instructions (except VMCALL) and IOPL instructions IN, INS, OUT, OUTS, CLI, STI)

pub fn is_stack_instruction(&self) -> bool

true if this is an instruction that implicitly uses the stack pointer (SP/ESP/RSP), eg. CALL, PUSH, POP, RET, etc. See also stack_pointer_increment()

Examples

use iced_x86::*;

// or ecx,esi
// push rax
let bytes = b"\x0B\xCE\x50";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// or ecx,esi
let instr = decoder.decode();
assert!(!instr.is_stack_instruction());

// push rax
let instr = decoder.decode();
assert!(instr.is_stack_instruction());
assert_eq!(instr.stack_pointer_increment(), -8);

pub fn is_save_restore_instruction(&self) -> bool

true if it’s an instruction that saves or restores too many registers (eg. FXRSTOR, XSAVE, etc).

pub fn rflags_read(&self) -> u32

All flags that are read by the CPU when executing the instruction. This method returns a RflagsBits value. See also rflags_modified().

Examples

use iced_x86::*;

// adc rsi,rcx
// xor rdi,5Ah
let bytes = b"\x48\x11\xCE\x48\x83\xF7\x5A";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// adc rsi,rcx
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::CF);
assert_eq!(instr.rflags_written(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::NONE);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::NONE);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

// xor rdi,5Ah
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::NONE);
assert_eq!(instr.rflags_written(), RflagsBits::SF | RflagsBits::ZF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::OF | RflagsBits::CF);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::AF);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

pub fn rflags_written(&self) -> u32

All flags that are written by the CPU, except those flags that are known to be undefined, always set or always cleared. This method returns a RflagsBits value. See also rflags_modified().

Examples

use iced_x86::*;

// adc rsi,rcx
// xor rdi,5Ah
let bytes = b"\x48\x11\xCE\x48\x83\xF7\x5A";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// adc rsi,rcx
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::CF);
assert_eq!(instr.rflags_written(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::NONE);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::NONE);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

// xor rdi,5Ah
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::NONE);
assert_eq!(instr.rflags_written(), RflagsBits::SF | RflagsBits::ZF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::OF | RflagsBits::CF);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::AF);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

pub fn rflags_cleared(&self) -> u32

All flags that are always cleared by the CPU. This method returns a RflagsBits value. See also rflags_modified().

Examples

use iced_x86::*;

// adc rsi,rcx
// xor rdi,5Ah
let bytes = b"\x48\x11\xCE\x48\x83\xF7\x5A";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// adc rsi,rcx
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::CF);
assert_eq!(instr.rflags_written(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::NONE);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::NONE);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

// xor rdi,5Ah
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::NONE);
assert_eq!(instr.rflags_written(), RflagsBits::SF | RflagsBits::ZF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::OF | RflagsBits::CF);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::AF);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

pub fn rflags_set(&self) -> u32

All flags that are always set by the CPU. This method returns a RflagsBits value. See also rflags_modified().

Examples

use iced_x86::*;

// adc rsi,rcx
// xor rdi,5Ah
let bytes = b"\x48\x11\xCE\x48\x83\xF7\x5A";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// adc rsi,rcx
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::CF);
assert_eq!(instr.rflags_written(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::NONE);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::NONE);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

// xor rdi,5Ah
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::NONE);
assert_eq!(instr.rflags_written(), RflagsBits::SF | RflagsBits::ZF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::OF | RflagsBits::CF);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::AF);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

pub fn rflags_undefined(&self) -> u32

All flags that are undefined after executing the instruction. This method returns a RflagsBits value. See also rflags_modified().

Examples

use iced_x86::*;

// adc rsi,rcx
// xor rdi,5Ah
let bytes = b"\x48\x11\xCE\x48\x83\xF7\x5A";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// adc rsi,rcx
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::CF);
assert_eq!(instr.rflags_written(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::NONE);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::NONE);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

// xor rdi,5Ah
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::NONE);
assert_eq!(instr.rflags_written(), RflagsBits::SF | RflagsBits::ZF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::OF | RflagsBits::CF);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::AF);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

pub fn rflags_modified(&self) -> u32

All flags that are modified by the CPU. This is rflags_written() + rflags_cleared() + rflags_set() + rflags_undefined(). This method returns a RflagsBits value.

Examples

use iced_x86::*;

// adc rsi,rcx
// xor rdi,5Ah
let bytes = b"\x48\x11\xCE\x48\x83\xF7\x5A";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// adc rsi,rcx
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::CF);
assert_eq!(instr.rflags_written(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::NONE);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::NONE);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

// xor rdi,5Ah
let instr = decoder.decode();
assert_eq!(instr.rflags_read(), RflagsBits::NONE);
assert_eq!(instr.rflags_written(), RflagsBits::SF | RflagsBits::ZF | RflagsBits::PF);
assert_eq!(instr.rflags_cleared(), RflagsBits::OF | RflagsBits::CF);
assert_eq!(instr.rflags_set(), RflagsBits::NONE);
assert_eq!(instr.rflags_undefined(), RflagsBits::AF);
assert_eq!(instr.rflags_modified(), RflagsBits::OF | RflagsBits::SF | RflagsBits::ZF | RflagsBits::AF | RflagsBits::CF | RflagsBits::PF);

pub fn is_jcc_short_or_near(&self) -> bool

Checks if it’s a Jcc SHORT or Jcc NEAR instruction

pub fn is_jcc_near(&self) -> bool

Checks if it’s a Jcc NEAR instruction

pub fn is_jcc_short(&self) -> bool

Checks if it’s a Jcc SHORT instruction

pub fn is_jmp_short(&self) -> bool

Checks if it’s a JMP SHORT instruction

pub fn is_jmp_near(&self) -> bool

Checks if it’s a JMP NEAR instruction

pub fn is_jmp_short_or_near(&self) -> bool

Checks if it’s a JMP SHORT or a JMP NEAR instruction

pub fn is_jmp_far(&self) -> bool

Checks if it’s a JMP FAR instruction

pub fn is_call_near(&self) -> bool

Checks if it’s a CALL NEAR instruction

pub fn is_call_far(&self) -> bool

Checks if it’s a CALL FAR instruction

pub fn is_jmp_near_indirect(&self) -> bool

Checks if it’s a JMP NEAR reg/[mem] instruction

pub fn is_jmp_far_indirect(&self) -> bool

Checks if it’s a JMP FAR [mem] instruction

pub fn is_call_near_indirect(&self) -> bool

Checks if it’s a CALL NEAR reg/[mem] instruction

pub fn is_call_far_indirect(&self) -> bool

Checks if it’s a CALL FAR [mem] instruction

pub fn negate_condition_code(&mut self)

Negates the condition code, eg. JE -> JNE. Can be used if it’s Jcc, SETcc, CMOVcc, LOOPcc and does nothing if the instruction doesn’t have a condition code.

Examples

use iced_x86::*;

// setbe al
let bytes = b"\x0F\x96\xC0";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

let mut instr = decoder.decode();
assert_eq!(instr.code(), Code::Setbe_rm8);
assert_eq!(instr.condition_code(), ConditionCode::be);
instr.negate_condition_code();
assert_eq!(instr.code(), Code::Seta_rm8);
assert_eq!(instr.condition_code(), ConditionCode::a);

pub fn as_short_branch(&mut self)

Converts Jcc/JMP NEAR to Jcc/JMP SHORT and does nothing if it’s not a Jcc/JMP NEAR instruction

Examples

use iced_x86::*;

// jbe near ptr label
let bytes = b"\x0F\x86\x5A\xA5\x12\x34";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

let mut instr = decoder.decode();
assert_eq!(instr.code(), Code::Jbe_rel32_64);
instr.as_short_branch();
assert_eq!(instr.code(), Code::Jbe_rel8_64);
instr.as_short_branch();
assert_eq!(instr.code(), Code::Jbe_rel8_64);

pub fn as_near_branch(&mut self)

Converts Jcc/JMP SHORT to Jcc/JMP NEAR and does nothing if it’s not a Jcc/JMP SHORT instruction

Examples

use iced_x86::*;

// jbe short label
let bytes = b"\x76\x5A";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

let mut instr = decoder.decode();
assert_eq!(instr.code(), Code::Jbe_rel8_64);
instr.as_near_branch();
assert_eq!(instr.code(), Code::Jbe_rel32_64);
instr.as_near_branch();
assert_eq!(instr.code(), Code::Jbe_rel32_64);

pub fn condition_code(&self) -> ConditionCode

Gets the condition code if it’s Jcc, SETcc, CMOVcc, LOOPcc else ConditionCode::None is returned

Examples

use iced_x86::*;

// setbe al
// jl short label
// cmovne ecx,esi
// nop
let bytes = b"\x0F\x96\xC0\x7C\x5A\x0F\x45\xCE\x90";
let mut decoder = Decoder::new(64, bytes, DecoderOptions::NONE);

// setbe al
let instr = decoder.decode();
assert_eq!(instr.condition_code(), ConditionCode::be);

// jl short label
let instr = decoder.decode();
assert_eq!(instr.condition_code(), ConditionCode::l);

// cmovne ecx,esi
let instr = decoder.decode();
assert_eq!(instr.condition_code(), ConditionCode::ne);

// nop
let instr = decoder.decode();
assert_eq!(instr.condition_code(), ConditionCode::None);

impl Instruction

pub fn op_code(&self) -> &'static OpCodeInfo

Gets the OpCodeInfo

impl Instruction

pub fn with(code: Code) -> Self

Creates an instruction with no operands

Arguments

• code: Code value

pub fn with_reg(code: Code, register: Register) -> Self

Creates an instruction with 1 operand

Arguments

• code: Code value
• register: op0: Register

pub fn try_with_i32(code: Code, immediate: i32) -> Result<Self, IcedError>

Creates an instruction with 1 operand

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• immediate: op0: Immediate value

pub fn with_i32(code: Code, immediate: i32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_i32() instead

Creates an instruction with 1 operand

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• immediate: op0: Immediate value

pub fn try_with_u32(code: Code, immediate: u32) -> Result<Self, IcedError>

Creates an instruction with 1 operand

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• immediate: op0: Immediate value

pub fn with_u32(code: Code, immediate: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_u32() instead

Creates an instruction with 1 operand

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• immediate: op0: Immediate value

pub fn with_mem(code: Code, memory: MemoryOperand) -> Self

Creates an instruction with 1 operand

Arguments

• code: Code value
• memory: op0: Memory operand

pub fn with_reg_reg(
    code: Code,
    register1: Register,
    register2: Register
) -> Self

Creates an instruction with 2 operands

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register

pub fn try_with_reg_i32(
    code: Code,
    register: Register,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate: op1: Immediate value

pub fn with_reg_i32(code: Code, register: Register, immediate: i32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_i32() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate: op1: Immediate value

pub fn try_with_reg_u32(
    code: Code,
    register: Register,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate: op1: Immediate value

pub fn with_reg_u32(code: Code, register: Register, immediate: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_u32() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate: op1: Immediate value

pub fn try_with_reg_i64(
    code: Code,
    register: Register,
    immediate: i64
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate: op1: Immediate value

pub fn with_reg_i64(code: Code, register: Register, immediate: i64) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_i64() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate: op1: Immediate value

pub fn try_with_reg_u64(
    code: Code,
    register: Register,
    immediate: u64
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate: op1: Immediate value

pub fn with_reg_u64(code: Code, register: Register, immediate: u64) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_u64() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate: op1: Immediate value

pub fn with_reg_mem(
    code: Code,
    register: Register,
    memory: MemoryOperand
) -> Self

Creates an instruction with 2 operands

Arguments

• code: Code value
• register: op0: Register
• memory: op1: Memory operand

pub fn try_with_i32_reg(
    code: Code,
    immediate: i32,
    register: Register
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• immediate: op0: Immediate value
• register: op1: Register

pub fn with_i32_reg(code: Code, immediate: i32, register: Register) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_i32_reg() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• immediate: op0: Immediate value
• register: op1: Register

pub fn try_with_u32_reg(
    code: Code,
    immediate: u32,
    register: Register
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• immediate: op0: Immediate value
• register: op1: Register

pub fn with_u32_reg(code: Code, immediate: u32, register: Register) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_u32_reg() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• immediate: op0: Immediate value
• register: op1: Register

pub fn try_with_i32_i32(
    code: Code,
    immediate1: i32,
    immediate2: i32
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• immediate1: op0: Immediate value
• immediate2: op1: Immediate value

pub fn with_i32_i32(code: Code, immediate1: i32, immediate2: i32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_i32_i32() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• immediate1: op0: Immediate value
• immediate2: op1: Immediate value

pub fn try_with_u32_u32(
    code: Code,
    immediate1: u32,
    immediate2: u32
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• immediate1: op0: Immediate value
• immediate2: op1: Immediate value

pub fn with_u32_u32(code: Code, immediate1: u32, immediate2: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_u32_u32() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• immediate1: op0: Immediate value
• immediate2: op1: Immediate value

pub fn with_mem_reg(
    code: Code,
    memory: MemoryOperand,
    register: Register
) -> Self

Creates an instruction with 2 operands

Arguments

• code: Code value
• memory: op0: Memory operand
• register: op1: Register

pub fn try_with_mem_i32(
    code: Code,
    memory: MemoryOperand,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• memory: op0: Memory operand
• immediate: op1: Immediate value

pub fn with_mem_i32(code: Code, memory: MemoryOperand, immediate: i32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_mem_i32() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• memory: op0: Memory operand
• immediate: op1: Immediate value

pub fn try_with_mem_u32(
    code: Code,
    memory: MemoryOperand,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 2 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• memory: op0: Memory operand
• immediate: op1: Immediate value

pub fn with_mem_u32(code: Code, memory: MemoryOperand, immediate: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_mem_u32() instead

Creates an instruction with 2 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• memory: op0: Memory operand
• immediate: op1: Immediate value

pub fn with_reg_reg_reg(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register
) -> Self

Creates an instruction with 3 operands

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register

pub fn try_with_reg_reg_i32(
    code: Code,
    register1: Register,
    register2: Register,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 3 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• immediate: op2: Immediate value

pub fn with_reg_reg_i32(
    code: Code,
    register1: Register,
    register2: Register,
    immediate: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_i32() instead

Creates an instruction with 3 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• immediate: op2: Immediate value

pub fn try_with_reg_reg_u32(
    code: Code,
    register1: Register,
    register2: Register,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 3 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• immediate: op2: Immediate value

pub fn with_reg_reg_u32(
    code: Code,
    register1: Register,
    register2: Register,
    immediate: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_u32() instead

Creates an instruction with 3 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• immediate: op2: Immediate value

pub fn with_reg_reg_mem(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand
) -> Self

Creates an instruction with 3 operands

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand

pub fn try_with_reg_i32_i32(
    code: Code,
    register: Register,
    immediate1: i32,
    immediate2: i32
) -> Result<Self, IcedError>

Creates an instruction with 3 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate1: op1: Immediate value
• immediate2: op2: Immediate value

pub fn with_reg_i32_i32(
    code: Code,
    register: Register,
    immediate1: i32,
    immediate2: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_i32_i32() instead

Creates an instruction with 3 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate1: op1: Immediate value
• immediate2: op2: Immediate value

pub fn try_with_reg_u32_u32(
    code: Code,
    register: Register,
    immediate1: u32,
    immediate2: u32
) -> Result<Self, IcedError>

Creates an instruction with 3 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate1: op1: Immediate value
• immediate2: op2: Immediate value

pub fn with_reg_u32_u32(
    code: Code,
    register: Register,
    immediate1: u32,
    immediate2: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_u32_u32() instead

Creates an instruction with 3 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• immediate1: op1: Immediate value
• immediate2: op2: Immediate value

pub fn with_reg_mem_reg(
    code: Code,
    register1: Register,
    memory: MemoryOperand,
    register2: Register
) -> Self

Creates an instruction with 3 operands

Arguments

• code: Code value
• register1: op0: Register
• memory: op1: Memory operand
• register2: op2: Register

pub fn try_with_reg_mem_i32(
    code: Code,
    register: Register,
    memory: MemoryOperand,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 3 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• memory: op1: Memory operand
• immediate: op2: Immediate value

pub fn with_reg_mem_i32(
    code: Code,
    register: Register,
    memory: MemoryOperand,
    immediate: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_mem_i32() instead

Creates an instruction with 3 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• memory: op1: Memory operand
• immediate: op2: Immediate value

pub fn try_with_reg_mem_u32(
    code: Code,
    register: Register,
    memory: MemoryOperand,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 3 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• memory: op1: Memory operand
• immediate: op2: Immediate value

pub fn with_reg_mem_u32(
    code: Code,
    register: Register,
    memory: MemoryOperand,
    immediate: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_mem_u32() instead

Creates an instruction with 3 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register: op0: Register
• memory: op1: Memory operand
• immediate: op2: Immediate value

pub fn with_mem_reg_reg(
    code: Code,
    memory: MemoryOperand,
    register1: Register,
    register2: Register
) -> Self

Creates an instruction with 3 operands

Arguments

• code: Code value
• memory: op0: Memory operand
• register1: op1: Register
• register2: op2: Register

pub fn try_with_mem_reg_i32(
    code: Code,
    memory: MemoryOperand,
    register: Register,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 3 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• memory: op0: Memory operand
• register: op1: Register
• immediate: op2: Immediate value

pub fn with_mem_reg_i32(
    code: Code,
    memory: MemoryOperand,
    register: Register,
    immediate: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_mem_reg_i32() instead

Creates an instruction with 3 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• memory: op0: Memory operand
• register: op1: Register
• immediate: op2: Immediate value

pub fn try_with_mem_reg_u32(
    code: Code,
    memory: MemoryOperand,
    register: Register,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 3 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• memory: op0: Memory operand
• register: op1: Register
• immediate: op2: Immediate value

pub fn with_mem_reg_u32(
    code: Code,
    memory: MemoryOperand,
    register: Register,
    immediate: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_mem_reg_u32() instead

Creates an instruction with 3 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• memory: op0: Memory operand
• register: op1: Register
• immediate: op2: Immediate value

pub fn with_reg_reg_reg_reg(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    register4: Register
) -> Self

Creates an instruction with 4 operands

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• register4: op3: Register

pub fn try_with_reg_reg_reg_i32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 4 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• immediate: op3: Immediate value

pub fn with_reg_reg_reg_i32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    immediate: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_reg_i32() instead

Creates an instruction with 4 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• immediate: op3: Immediate value

pub fn try_with_reg_reg_reg_u32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 4 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• immediate: op3: Immediate value

pub fn with_reg_reg_reg_u32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    immediate: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_reg_u32() instead

Creates an instruction with 4 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• immediate: op3: Immediate value

pub fn with_reg_reg_reg_mem(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    memory: MemoryOperand
) -> Self

Creates an instruction with 4 operands

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• memory: op3: Memory operand

pub fn try_with_reg_reg_i32_i32(
    code: Code,
    register1: Register,
    register2: Register,
    immediate1: i32,
    immediate2: i32
) -> Result<Self, IcedError>

Creates an instruction with 4 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• immediate1: op2: Immediate value
• immediate2: op3: Immediate value

pub fn with_reg_reg_i32_i32(
    code: Code,
    register1: Register,
    register2: Register,
    immediate1: i32,
    immediate2: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_i32_i32() instead

Creates an instruction with 4 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• immediate1: op2: Immediate value
• immediate2: op3: Immediate value

pub fn try_with_reg_reg_u32_u32(
    code: Code,
    register1: Register,
    register2: Register,
    immediate1: u32,
    immediate2: u32
) -> Result<Self, IcedError>

Creates an instruction with 4 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• immediate1: op2: Immediate value
• immediate2: op3: Immediate value

pub fn with_reg_reg_u32_u32(
    code: Code,
    register1: Register,
    register2: Register,
    immediate1: u32,
    immediate2: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_u32_u32() instead

Creates an instruction with 4 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• immediate1: op2: Immediate value
• immediate2: op3: Immediate value

pub fn with_reg_reg_mem_reg(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand,
    register3: Register
) -> Self

Creates an instruction with 4 operands

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand
• register3: op3: Register

pub fn try_with_reg_reg_mem_i32(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 4 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand
• immediate: op3: Immediate value

pub fn with_reg_reg_mem_i32(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand,
    immediate: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_mem_i32() instead

Creates an instruction with 4 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand
• immediate: op3: Immediate value

pub fn try_with_reg_reg_mem_u32(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 4 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand
• immediate: op3: Immediate value

pub fn with_reg_reg_mem_u32(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand,
    immediate: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_mem_u32() instead

Creates an instruction with 4 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand
• immediate: op3: Immediate value

pub fn try_with_reg_reg_reg_reg_i32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    register4: Register,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 5 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• register4: op3: Register
• immediate: op4: Immediate value

pub fn with_reg_reg_reg_reg_i32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    register4: Register,
    immediate: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_reg_reg_i32() instead

Creates an instruction with 5 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• register4: op3: Register
• immediate: op4: Immediate value

pub fn try_with_reg_reg_reg_reg_u32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    register4: Register,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 5 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• register4: op3: Register
• immediate: op4: Immediate value

pub fn with_reg_reg_reg_reg_u32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    register4: Register,
    immediate: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_reg_reg_u32() instead

Creates an instruction with 5 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• register4: op3: Register
• immediate: op4: Immediate value

pub fn try_with_reg_reg_reg_mem_i32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    memory: MemoryOperand,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 5 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• memory: op3: Memory operand
• immediate: op4: Immediate value

pub fn with_reg_reg_reg_mem_i32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    memory: MemoryOperand,
    immediate: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_reg_mem_i32() instead

Creates an instruction with 5 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• memory: op3: Memory operand
• immediate: op4: Immediate value

pub fn try_with_reg_reg_reg_mem_u32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    memory: MemoryOperand,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 5 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• memory: op3: Memory operand
• immediate: op4: Immediate value

pub fn with_reg_reg_reg_mem_u32(
    code: Code,
    register1: Register,
    register2: Register,
    register3: Register,
    memory: MemoryOperand,
    immediate: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_reg_mem_u32() instead

Creates an instruction with 5 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• register3: op2: Register
• memory: op3: Memory operand
• immediate: op4: Immediate value

pub fn try_with_reg_reg_mem_reg_i32(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand,
    register3: Register,
    immediate: i32
) -> Result<Self, IcedError>

Creates an instruction with 5 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand
• register3: op3: Register
• immediate: op4: Immediate value

pub fn with_reg_reg_mem_reg_i32(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand,
    register3: Register,
    immediate: i32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_mem_reg_i32() instead

Creates an instruction with 5 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand
• register3: op3: Register
• immediate: op4: Immediate value

pub fn try_with_reg_reg_mem_reg_u32(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand,
    register3: Register,
    immediate: u32
) -> Result<Self, IcedError>

Creates an instruction with 5 operands

Errors

Fails if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand
• register3: op3: Register
• immediate: op4: Immediate value

pub fn with_reg_reg_mem_reg_u32(
    code: Code,
    register1: Register,
    register2: Register,
    memory: MemoryOperand,
    register3: Register,
    immediate: u32
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_reg_reg_mem_reg_u32() instead

Creates an instruction with 5 operands

Panics

Panics if the immediate is invalid

Arguments

• code: Code value
• register1: op0: Register
• register2: op1: Register
• memory: op2: Memory operand
• register3: op3: Register
• immediate: op4: Immediate value

pub fn try_with_branch(code: Code, target: u64) -> Result<Self, IcedError>

Creates a new near/short branch instruction

Errors

Fails if the created instruction doesn’t have a near branch operand

Arguments

• code: Code value
• target: Target address

pub fn with_branch(code: Code, target: u64) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_branch() instead

Creates a new near/short branch instruction

Panics

Panics if the created instruction doesn’t have a near branch operand

Arguments

• code: Code value
• target: Target address

pub fn try_with_far_branch(
    code: Code,
    selector: u16,
    offset: u32
) -> Result<Self, IcedError>

Creates a new far branch instruction

Errors

Fails if the created instruction doesn’t have a far branch operand

Arguments

• code: Code value
• selector: Selector/segment value
• offset: Offset

pub fn with_far_branch(code: Code, selector: u16, offset: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_far_branch() instead

Creates a new far branch instruction

Panics

Panics if the created instruction doesn’t have a far branch operand

Arguments

• code: Code value
• selector: Selector/segment value
• offset: Offset

pub fn try_with_xbegin(bitness: u32, target: u64) -> Result<Self, IcedError>

Creates a new XBEGIN instruction

Errors

Fails if bitness is not one of 16, 32, 64.

Arguments

• bitness: 16, 32, or 64
• target: Target address

pub fn with_xbegin(bitness: u32, target: u64) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_xbegin() instead

Creates a new XBEGIN instruction

Panics

Panics if bitness is not one of 16, 32, 64.

Arguments

• bitness: 16, 32, or 64
• target: Target address

pub fn with_reg_mem64(
    code: Code,
    register: Register,
    address: u64,
    segment_prefix: Register
) -> Self

👎 Deprecated since 1.11.0:

Use with_reg_mem() with a MemoryOperand arg instead

Creates an instruction with a 64-bit memory offset as the second operand, eg. mov al,[123456789ABCDEF0]

Arguments

• code: Code value
• register: Register (AL, AX, EAX, RAX)
• address: 64-bit address
• segment_prefix: Segment override or Register::None

pub fn with_mem64_reg(
    code: Code,
    address: u64,
    register: Register,
    segment_prefix: Register
) -> Self

👎 Deprecated since 1.11.0:

Use with_mem_reg() with a MemoryOperand arg instead

Creates an instruction with a 64-bit memory offset as the first operand, eg. mov [123456789ABCDEF0],al

Arguments

• code: Code value
• address: 64-bit address
• register: Register (AL, AX, EAX, RAX)
• segment_prefix: Segment override or Register::None

pub fn try_with_outsb(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a OUTSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_outsb(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_outsb() instead

Creates a OUTSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_outsb(address_size: u32) -> Result<Self, IcedError>

Creates a REP OUTSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_outsb(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_outsb() instead

Creates a REP OUTSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_outsw(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a OUTSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_outsw(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_outsw() instead

Creates a OUTSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_outsw(address_size: u32) -> Result<Self, IcedError>

Creates a REP OUTSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_outsw(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_outsw() instead

Creates a REP OUTSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_outsd(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a OUTSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_outsd(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_outsd() instead

Creates a OUTSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_outsd(address_size: u32) -> Result<Self, IcedError>

Creates a REP OUTSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_outsd(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_outsd() instead

Creates a REP OUTSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_lodsb(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a LODSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_lodsb(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_lodsb() instead

Creates a LODSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_lodsb(address_size: u32) -> Result<Self, IcedError>

Creates a REP LODSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_lodsb(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_lodsb() instead

Creates a REP LODSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_lodsw(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a LODSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_lodsw(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_lodsw() instead

Creates a LODSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_lodsw(address_size: u32) -> Result<Self, IcedError>

Creates a REP LODSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_lodsw(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_lodsw() instead

Creates a REP LODSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_lodsd(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a LODSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_lodsd(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_lodsd() instead

Creates a LODSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_lodsd(address_size: u32) -> Result<Self, IcedError>

Creates a REP LODSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_lodsd(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_lodsd() instead

Creates a REP LODSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_lodsq(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a LODSQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_lodsq(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_lodsq() instead

Creates a LODSQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_lodsq(address_size: u32) -> Result<Self, IcedError>

Creates a REP LODSQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_lodsq(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_lodsq() instead

Creates a REP LODSQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_scasb(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a SCASB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_scasb(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_scasb() instead

Creates a SCASB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_repe_scasb(address_size: u32) -> Result<Self, IcedError>

Creates a REPE SCASB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repe_scasb(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repe_scasb() instead

Creates a REPE SCASB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_repne_scasb(address_size: u32) -> Result<Self, IcedError>

Creates a REPNE SCASB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repne_scasb(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repne_scasb() instead

Creates a REPNE SCASB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_scasw(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a SCASW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_scasw(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_scasw() instead

Creates a SCASW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_repe_scasw(address_size: u32) -> Result<Self, IcedError>

Creates a REPE SCASW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repe_scasw(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repe_scasw() instead

Creates a REPE SCASW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_repne_scasw(address_size: u32) -> Result<Self, IcedError>

Creates a REPNE SCASW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repne_scasw(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repne_scasw() instead

Creates a REPNE SCASW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_scasd(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a SCASD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_scasd(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_scasd() instead

Creates a SCASD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_repe_scasd(address_size: u32) -> Result<Self, IcedError>

Creates a REPE SCASD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repe_scasd(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repe_scasd() instead

Creates a REPE SCASD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_repne_scasd(address_size: u32) -> Result<Self, IcedError>

Creates a REPNE SCASD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repne_scasd(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repne_scasd() instead

Creates a REPNE SCASD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_scasq(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a SCASQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_scasq(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_scasq() instead

Creates a SCASQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_repe_scasq(address_size: u32) -> Result<Self, IcedError>

Creates a REPE SCASQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repe_scasq(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repe_scasq() instead

Creates a REPE SCASQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_repne_scasq(address_size: u32) -> Result<Self, IcedError>

Creates a REPNE SCASQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repne_scasq(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repne_scasq() instead

Creates a REPNE SCASQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_insb(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a INSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_insb(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_insb() instead

Creates a INSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_insb(address_size: u32) -> Result<Self, IcedError>

Creates a REP INSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_insb(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_insb() instead

Creates a REP INSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_insw(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a INSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_insw(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_insw() instead

Creates a INSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_insw(address_size: u32) -> Result<Self, IcedError>

Creates a REP INSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_insw(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_insw() instead

Creates a REP INSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_insd(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a INSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_insd(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_insd() instead

Creates a INSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_insd(address_size: u32) -> Result<Self, IcedError>

Creates a REP INSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_insd(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_insd() instead

Creates a REP INSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_stosb(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a STOSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_stosb(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_stosb() instead

Creates a STOSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_stosb(address_size: u32) -> Result<Self, IcedError>

Creates a REP STOSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_stosb(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_stosb() instead

Creates a REP STOSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_stosw(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a STOSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_stosw(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_stosw() instead

Creates a STOSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_stosw(address_size: u32) -> Result<Self, IcedError>

Creates a REP STOSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_stosw(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_stosw() instead

Creates a REP STOSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_stosd(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a STOSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_stosd(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_stosd() instead

Creates a STOSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_stosd(address_size: u32) -> Result<Self, IcedError>

Creates a REP STOSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_stosd(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_stosd() instead

Creates a REP STOSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_stosq(
    address_size: u32,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a STOSQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_stosq(address_size: u32, rep_prefix: RepPrefixKind) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_stosq() instead

Creates a STOSQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_stosq(address_size: u32) -> Result<Self, IcedError>

Creates a REP STOSQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_stosq(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_stosq() instead

Creates a REP STOSQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_cmpsb(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a CMPSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_cmpsb(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_cmpsb() instead

Creates a CMPSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_repe_cmpsb(address_size: u32) -> Result<Self, IcedError>

Creates a REPE CMPSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repe_cmpsb(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repe_cmpsb() instead

Creates a REPE CMPSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_repne_cmpsb(address_size: u32) -> Result<Self, IcedError>

Creates a REPNE CMPSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repne_cmpsb(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repne_cmpsb() instead

Creates a REPNE CMPSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_cmpsw(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a CMPSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_cmpsw(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_cmpsw() instead

Creates a CMPSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_repe_cmpsw(address_size: u32) -> Result<Self, IcedError>

Creates a REPE CMPSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repe_cmpsw(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repe_cmpsw() instead

Creates a REPE CMPSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_repne_cmpsw(address_size: u32) -> Result<Self, IcedError>

Creates a REPNE CMPSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repne_cmpsw(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repne_cmpsw() instead

Creates a REPNE CMPSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_cmpsd(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a CMPSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_cmpsd(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_cmpsd() instead

Creates a CMPSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_repe_cmpsd(address_size: u32) -> Result<Self, IcedError>

Creates a REPE CMPSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repe_cmpsd(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repe_cmpsd() instead

Creates a REPE CMPSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_repne_cmpsd(address_size: u32) -> Result<Self, IcedError>

Creates a REPNE CMPSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repne_cmpsd(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repne_cmpsd() instead

Creates a REPNE CMPSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_cmpsq(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a CMPSQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_cmpsq(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_cmpsq() instead

Creates a CMPSQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_repe_cmpsq(address_size: u32) -> Result<Self, IcedError>

Creates a REPE CMPSQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repe_cmpsq(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repe_cmpsq() instead

Creates a REPE CMPSQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_repne_cmpsq(address_size: u32) -> Result<Self, IcedError>

Creates a REPNE CMPSQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_repne_cmpsq(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_repne_cmpsq() instead

Creates a REPNE CMPSQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_movsb(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a MOVSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_movsb(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_movsb() instead

Creates a MOVSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_movsb(address_size: u32) -> Result<Self, IcedError>

Creates a REP MOVSB instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_movsb(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_movsb() instead

Creates a REP MOVSB instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_movsw(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a MOVSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_movsw(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_movsw() instead

Creates a MOVSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_movsw(address_size: u32) -> Result<Self, IcedError>

Creates a REP MOVSW instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_movsw(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_movsw() instead

Creates a REP MOVSW instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_movsd(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a MOVSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_movsd(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_movsd() instead

Creates a MOVSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_movsd(address_size: u32) -> Result<Self, IcedError>

Creates a REP MOVSD instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_movsd(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_movsd() instead

Creates a REP MOVSD instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_movsq(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Result<Self, IcedError>

Creates a MOVSQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn with_movsq(
    address_size: u32,
    segment_prefix: Register,
    rep_prefix: RepPrefixKind
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_movsq() instead

Creates a MOVSQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• segment_prefix: Segment override or Register::None
• rep_prefix: Rep prefix or RepPrefixKind::None

pub fn try_with_rep_movsq(address_size: u32) -> Result<Self, IcedError>

Creates a REP MOVSQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn with_rep_movsq(address_size: u32) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_rep_movsq() instead

Creates a REP MOVSQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64

pub fn try_with_maskmovq(
    address_size: u32,
    register1: Register,
    register2: Register,
    segment_prefix: Register
) -> Result<Self, IcedError>

Creates a MASKMOVQ instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• register1: Register
• register2: Register
• segment_prefix: Segment override or Register::None

pub fn with_maskmovq(
    address_size: u32,
    register1: Register,
    register2: Register,
    segment_prefix: Register
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_maskmovq() instead

Creates a MASKMOVQ instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• register1: Register
• register2: Register
• segment_prefix: Segment override or Register::None

pub fn try_with_maskmovdqu(
    address_size: u32,
    register1: Register,
    register2: Register,
    segment_prefix: Register
) -> Result<Self, IcedError>

Creates a MASKMOVDQU instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• register1: Register
• register2: Register
• segment_prefix: Segment override or Register::None

pub fn with_maskmovdqu(
    address_size: u32,
    register1: Register,
    register2: Register,
    segment_prefix: Register
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_maskmovdqu() instead

Creates a MASKMOVDQU instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• register1: Register
• register2: Register
• segment_prefix: Segment override or Register::None

pub fn try_with_vmaskmovdqu(
    address_size: u32,
    register1: Register,
    register2: Register,
    segment_prefix: Register
) -> Result<Self, IcedError>

Creates a VMASKMOVDQU instruction

Errors

Fails if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• register1: Register
• register2: Register
• segment_prefix: Segment override or Register::None

pub fn with_vmaskmovdqu(
    address_size: u32,
    register1: Register,
    register2: Register,
    segment_prefix: Register
) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_vmaskmovdqu() instead

Creates a VMASKMOVDQU instruction

Panics

Panics if address_size is not one of 16, 32, 64.

Arguments

• address_size: 16, 32, or 64
• register1: Register
• register2: Register
• segment_prefix: Segment override or Register::None

pub fn with_declare_byte_1(b0: u8) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0

pub fn with_declare_byte_2(b0: u8, b1: u8) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1

pub fn with_declare_byte_3(b0: u8, b1: u8, b2: u8) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2

pub fn with_declare_byte_4(b0: u8, b1: u8, b2: u8, b3: u8) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3

pub fn with_declare_byte_5(b0: u8, b1: u8, b2: u8, b3: u8, b4: u8) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4

pub fn with_declare_byte_6(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5

pub fn with_declare_byte_7(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6

pub fn with_declare_byte_8(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8,
    b7: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6
• b7: Byte 7

pub fn with_declare_byte_9(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8,
    b7: u8,
    b8: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6
• b7: Byte 7
• b8: Byte 8

pub fn with_declare_byte_10(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8,
    b7: u8,
    b8: u8,
    b9: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6
• b7: Byte 7
• b8: Byte 8
• b9: Byte 9

pub fn with_declare_byte_11(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8,
    b7: u8,
    b8: u8,
    b9: u8,
    b10: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6
• b7: Byte 7
• b8: Byte 8
• b9: Byte 9
• b10: Byte 10

pub fn with_declare_byte_12(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8,
    b7: u8,
    b8: u8,
    b9: u8,
    b10: u8,
    b11: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6
• b7: Byte 7
• b8: Byte 8
• b9: Byte 9
• b10: Byte 10
• b11: Byte 11

pub fn with_declare_byte_13(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8,
    b7: u8,
    b8: u8,
    b9: u8,
    b10: u8,
    b11: u8,
    b12: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6
• b7: Byte 7
• b8: Byte 8
• b9: Byte 9
• b10: Byte 10
• b11: Byte 11
• b12: Byte 12

pub fn with_declare_byte_14(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8,
    b7: u8,
    b8: u8,
    b9: u8,
    b10: u8,
    b11: u8,
    b12: u8,
    b13: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6
• b7: Byte 7
• b8: Byte 8
• b9: Byte 9
• b10: Byte 10
• b11: Byte 11
• b12: Byte 12
• b13: Byte 13

pub fn with_declare_byte_15(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8,
    b7: u8,
    b8: u8,
    b9: u8,
    b10: u8,
    b11: u8,
    b12: u8,
    b13: u8,
    b14: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6
• b7: Byte 7
• b8: Byte 8
• b9: Byte 9
• b10: Byte 10
• b11: Byte 11
• b12: Byte 12
• b13: Byte 13
• b14: Byte 14

pub fn with_declare_byte_16(
    b0: u8,
    b1: u8,
    b2: u8,
    b3: u8,
    b4: u8,
    b5: u8,
    b6: u8,
    b7: u8,
    b8: u8,
    b9: u8,
    b10: u8,
    b11: u8,
    b12: u8,
    b13: u8,
    b14: u8,
    b15: u8
) -> Self

Creates a db/.byte asm directive

Arguments

• b0: Byte 0
• b1: Byte 1
• b2: Byte 2
• b3: Byte 3
• b4: Byte 4
• b5: Byte 5
• b6: Byte 6
• b7: Byte 7
• b8: Byte 8
• b9: Byte 9
• b10: Byte 10
• b11: Byte 11
• b12: Byte 12
• b13: Byte 13
• b14: Byte 14
• b15: Byte 15

pub fn try_with_declare_byte(data: &[u8]) -> Result<Self, IcedError>

Creates a db/.byte asm directive

Errors

Fails if data.len() is not 1-16

Arguments

• data: Data

pub fn with_declare_byte(data: &[u8]) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_declare_byte() instead

Creates a db/.byte asm directive

Panics

Panics if data.len() is not 1-16

Arguments

• data: Data

pub fn with_declare_word_1(w0: u16) -> Self

Creates a dw/.word asm directive

Arguments

• w0: Word 0

pub fn with_declare_word_2(w0: u16, w1: u16) -> Self

Creates a dw/.word asm directive

Arguments

• w0: Word 0
• w1: Word 1

pub fn with_declare_word_3(w0: u16, w1: u16, w2: u16) -> Self

Creates a dw/.word asm directive

Arguments

• w0: Word 0
• w1: Word 1
• w2: Word 2

pub fn with_declare_word_4(w0: u16, w1: u16, w2: u16, w3: u16) -> Self

Creates a dw/.word asm directive

Arguments

• w0: Word 0
• w1: Word 1
• w2: Word 2
• w3: Word 3

pub fn with_declare_word_5(w0: u16, w1: u16, w2: u16, w3: u16, w4: u16) -> Self

Creates a dw/.word asm directive

Arguments

• w0: Word 0
• w1: Word 1
• w2: Word 2
• w3: Word 3
• w4: Word 4

pub fn with_declare_word_6(
    w0: u16,
    w1: u16,
    w2: u16,
    w3: u16,
    w4: u16,
    w5: u16
) -> Self

Creates a dw/.word asm directive

Arguments

• w0: Word 0
• w1: Word 1
• w2: Word 2
• w3: Word 3
• w4: Word 4
• w5: Word 5

pub fn with_declare_word_7(
    w0: u16,
    w1: u16,
    w2: u16,
    w3: u16,
    w4: u16,
    w5: u16,
    w6: u16
) -> Self

Creates a dw/.word asm directive

Arguments

• w0: Word 0
• w1: Word 1
• w2: Word 2
• w3: Word 3
• w4: Word 4
• w5: Word 5
• w6: Word 6

pub fn with_declare_word_8(
    w0: u16,
    w1: u16,
    w2: u16,
    w3: u16,
    w4: u16,
    w5: u16,
    w6: u16,
    w7: u16
) -> Self

Creates a dw/.word asm directive

Arguments

• w0: Word 0
• w1: Word 1
• w2: Word 2
• w3: Word 3
• w4: Word 4
• w5: Word 5
• w6: Word 6
• w7: Word 7

pub fn try_with_declare_word_slice_u8(data: &[u8]) -> Result<Self, IcedError>

Creates a dw/.word asm directive

Errors

Fails if data.len() is not 2-16 or not a multiple of 2

Arguments

• data: Data

pub fn with_declare_word_slice_u8(data: &[u8]) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_declare_word_slice_u8() instead

Creates a dw/.word asm directive

Panics

Panics if data.len() is not 2-16 or not a multiple of 2

Arguments

• data: Data

pub fn try_with_declare_word(data: &[u16]) -> Result<Self, IcedError>

Creates a dw/.word asm directive

Errors

Fails if data.len() is not 1-8

Arguments

• data: Data

pub fn with_declare_word(data: &[u16]) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_declare_word() instead

Creates a dw/.word asm directive

Panics

Panics if data.len() is not 1-8

Arguments

• data: Data

pub fn with_declare_dword_1(d0: u32) -> Self

Creates a dd/.int asm directive

Arguments

• d0: Dword 0

pub fn with_declare_dword_2(d0: u32, d1: u32) -> Self

Creates a dd/.int asm directive

Arguments

• d0: Dword 0
• d1: Dword 1

pub fn with_declare_dword_3(d0: u32, d1: u32, d2: u32) -> Self

Creates a dd/.int asm directive

Arguments

• d0: Dword 0
• d1: Dword 1
• d2: Dword 2

pub fn with_declare_dword_4(d0: u32, d1: u32, d2: u32, d3: u32) -> Self

Creates a dd/.int asm directive

Arguments

• d0: Dword 0
• d1: Dword 1
• d2: Dword 2
• d3: Dword 3

pub fn try_with_declare_dword_slice_u8(data: &[u8]) -> Result<Self, IcedError>

Creates a dd/.int asm directive

Errors

Fails if data.len() is not 4-16 or not a multiple of 4

Arguments

• data: Data

pub fn with_declare_dword_slice_u8(data: &[u8]) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_declare_dword_slice_u8() instead

Creates a dd/.int asm directive

Panics

Panics if data.len() is not 4-16 or not a multiple of 4

Arguments

• data: Data

pub fn try_with_declare_dword(data: &[u32]) -> Result<Self, IcedError>

Creates a dd/.int asm directive

Errors

Fails if data.len() is not 1-4

Arguments

• data: Data

pub fn with_declare_dword(data: &[u32]) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_declare_dword() instead

Creates a dd/.int asm directive

Panics

Panics if data.len() is not 1-4

Arguments

• data: Data

pub fn with_declare_qword_1(q0: u64) -> Self

Creates a dq/.quad asm directive

Arguments

• q0: Qword 0

pub fn with_declare_qword_2(q0: u64, q1: u64) -> Self

Creates a dq/.quad asm directive

Arguments

• q0: Qword 0
• q1: Qword 1

pub fn try_with_declare_qword_slice_u8(data: &[u8]) -> Result<Self, IcedError>

Creates a dq/.quad asm directive

Errors

Fails if data.len() is not 8-16 or not a multiple of 8

Arguments

• data: Data

pub fn with_declare_qword_slice_u8(data: &[u8]) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_declare_qword_slice_u8() instead

Creates a dq/.quad asm directive

Panics

Panics if data.len() is not 8-16 or not a multiple of 8

Arguments

• data: Data

pub fn try_with_declare_qword(data: &[u64]) -> Result<Self, IcedError>

Creates a dq/.quad asm directive

Errors

Fails if data.len() is not 1-2

Arguments

• data: Data

pub fn with_declare_qword(data: &[u64]) -> Self

👎 Deprecated since 1.10.0:

This method can panic, use try_with_declare_qword() instead

Creates a dq/.quad asm directive

Panics

Panics if data.len() is not 1-2

Arguments

• data: Data

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a copy 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 Default for Instruction

fn default() -> Instruction

Returns the “default value” for a type.

impl Display 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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Instruction> for Instruction

fn eq(&self, other: &Self) -> 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 !=.

impl Copy for Instruction

impl Eq for Instruction