Struct iced_x86::code_asm::CodeAssembler

pub struct CodeAssembler { /* fields omitted */ }

Creates and encodes instructions. It’s easier to use this struct than to call Instruction::with*() functions.

This requires the code_asm feature to use (not enabled by default). Add it to your Cargo.toml:

[dependencies.iced-x86]
version = "1.15.0"
features = ["code_asm"]

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;

// Anytime you add something to a register (or subtract from it), you create a
// memory operand. You can also call word_ptr(), dword_bcst() etc to create memory
// operands.
let _ = rax; // register
let _ = rax + 0; // memory with no size hint
let _ = ptr(rax); // memory with no size hint
let _ = rax + rcx * 4 - 123; // memory with no size hint
// To create a memory operand with only a displacement or only a base register,
// you can call one of the memory fns:
let _ = qword_ptr(123); // memory with a qword size hint
let _ = dword_bcst(rcx); // memory (broadcast) with a dword size hint
// To add a segment override, call the segment methods:
let _ = ptr(rax).fs(); // fs:[rax]

// Each mnemonic is a method
a.push(rcx)?;
// There are a few exceptions where you must append `_<opcount>` to the mnemonic to
// get the instruction you need:
a.ret()?;
a.ret_1(123)?;
// Use byte_ptr(), word_bcst(), etc to force the arg to a memory operand and to add a
// size hint
a.xor(byte_ptr(rdx+r14*4+123), 0x10)?;
// Prefixes are also methods
a.rep().stosd()?;
// Sometimes, you must add an integer suffix to help the compiler:
a.mov(rax, 0x1234_5678_9ABC_DEF0u64)?;

// Create labels that can be referenced by code
let mut loop_lbl1 = a.create_label();
let mut after_loop1 = a.create_label();
a.mov(ecx, 10)?;
a.set_label(&mut loop_lbl1)?;
a.dec(ecx)?;
a.jp(after_loop1)?;
a.jne(loop_lbl1)?;
a.set_label(&mut after_loop1)?;

// It's possible to reference labels with RIP-relative addressing
let mut skip_data = a.create_label();
let mut data = a.create_label();
a.jmp(skip_data)?;
a.set_label(&mut data)?;
a.db(b"\x90\xCC\xF1\x90")?;
a.set_label(&mut skip_data)?;
a.lea(rax, ptr(data))?;

// AVX512 opmasks, {z}, {sae}, {er} and broadcasting are also supported:
a.vsqrtps(zmm16.k2().z(), dword_bcst(rcx))?;
a.vsqrtps(zmm1.k2().z(), zmm23.rd_sae())?;
// Sometimes, the encoder doesn't know if you want VEX or EVEX encoding.
// You can force EVEX globally like so:
a.set_prefer_vex(false);
a.vucomiss(xmm31, xmm15.sae())?;
a.vucomiss(xmm31, ptr(rcx))?;
// or call vex()/evex() to override the encoding option:
a.evex().vucomiss(xmm31, xmm15.sae())?;
a.vex().vucomiss(xmm15, xmm14)?;

// Encode all added instructions
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes.len(), 82);
// If you don't want to encode them, you can get all instructions by calling
// one of these methods:
let instrs = a.instructions(); // Get a reference to the internal vec
assert_eq!(instrs.len(), 19);
let instrs = a.take_instructions(); // Take ownership of the vec with all instructions
assert_eq!(instrs.len(), 19);
assert_eq!(a.instructions().len(), 0);

Implementations

impl CodeAssembler

pub fn new(bitness: u32) -> Result<CodeAssembler, IcedError>

Creates a new instance

Errors

Fails if bitness is invalid

Arguments

• bitness: 16, 32, or 64

pub fn xacquire(&mut self) -> &mut Self

Adds an XACQUIRE prefix to the next added instruction

pub fn xrelease(&mut self) -> &mut Self

Adds an XRELEASE prefix to the next added instruction

pub fn lock(&mut self) -> &mut Self

Adds a LOCK prefix to the next added instruction

pub fn rep(&mut self) -> &mut Self

Adds a REP prefix to the next added instruction

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;

a.rep().stosq()?;
a.nop()?;

let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, vec![0xF3, 0x48, 0xAB, 0x90]);

pub fn repe(&mut self) -> &mut Self

Adds a REPE/REPZ prefix to the next added instruction

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;

a.repe().cmpsb()?;
a.nop()?;

let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, vec![0xF3, 0xA6, 0x90]);

pub fn repz(&mut self) -> &mut Self

Adds a REPE/REPZ prefix to the next added instruction

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;

a.repz().cmpsb()?;
a.nop()?;

let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, vec![0xF3, 0xA6, 0x90]);

pub fn repne(&mut self) -> &mut Self

Adds a REPNE/REPNZ prefix to the next added instruction

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;

a.repne().scasb()?;
a.nop()?;

let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, vec![0xF2, 0xAE, 0x90]);

pub fn repnz(&mut self) -> &mut Self

Adds a REPNE/REPNZ prefix to the next added instruction

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;

a.repnz().scasb()?;
a.nop()?;

let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, vec![0xF2, 0xAE, 0x90]);

pub fn bnd(&mut self) -> &mut Self

Adds a BND prefix to the next added instruction

pub fn notrack(&mut self) -> &mut Self

Adds a NOTRACK prefix to the next added instruction

pub fn vex(&mut self) -> &mut Self

Prefer VEX encoding if the next instruction can be VEX and EVEX encoded

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;

// This instruction can be VEX and EVEX encoded
a.vex().vaddpd(xmm1, xmm2, xmm3)?;
a.evex().vaddpd(xmm1, xmm2, xmm3)?;

let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xC5\xE9\x58\xCB\x62\xF1\xED\x08\x58\xCB");

pub fn evex(&mut self) -> &mut Self

Prefer EVEX encoding if the next instruction can be VEX and EVEX encoded

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;

// This instruction can be VEX and EVEX encoded
a.vex().vaddpd(xmm1, xmm2, xmm3)?;
a.evex().vaddpd(xmm1, xmm2, xmm3)?;

let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xC5\xE9\x58\xCB\x62\xF1\xED\x08\x58\xCB");

pub fn instructions(&self) -> &[Instruction]

Gets all added instructions, see also take_instructions() and assemble()

Examples

use iced_x86::*;
use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.push(rcx)?;
a.xor(rcx, rdx)?;
assert_eq!(a.instructions(), &[
    Instruction::with1(Code::Push_r64, Register::RCX)?,
    Instruction::with2(Code::Xor_rm64_r64, Register::RCX, Register::RDX)?,
]);

pub fn take_instructions(&mut self) -> Vec<Instruction>

Takes ownership of all instructions and returns them. Instruction state is also reset (see reset())

Examples

use iced_x86::*;
use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.push(rcx)?;
a.xor(rcx, rdx)?;
assert_eq!(a.instructions().len(), 2);
let instrs = a.take_instructions();
assert_eq!(a.instructions().len(), 0);
assert_eq!(instrs.len(), 2);
assert_eq!(instrs, vec![
    Instruction::with1(Code::Push_r64, Register::RCX)?,
    Instruction::with2(Code::Xor_rm64_r64, Register::RCX, Register::RDX)?,
]);

pub fn reset(&mut self)

Resets all instructions and labels so this instance can be re-used

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.push(rcx)?;
a.xor(rcx, rdx)?;
assert_eq!(a.instructions().len(), 2);
a.reset();
assert_eq!(a.instructions().len(), 0);

pub fn create_label(&mut self) -> CodeLabel

Creates a label that can be referenced by instructions

pub fn set_label(&mut self, label: &mut CodeLabel) -> Result<(), IcedError>

Initializes the label to the next instruction

Errors

Fails if the label wasn’t created by create_label(), if this method was called multiple times for the same label, or if the next instruction already has a label.

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
let mut label1 = a.create_label();
a.push(rcx)?;
// The address of this label is the next added instruction
a.set_label(&mut label1)?;
a.xor(rcx, rdx)?;
// Target is the `xor rcx, rdx` instruction
a.je(label1)?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\x51\x48\x31\xD1\x74\xFB\x90");

pub fn anonymous_label(&mut self) -> Result<(), IcedError>

Creates an anonymous label that can be referenced by calling bwd() and fwd()

Errors

Fails if the next instruction already has an anonymous label

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.push(rcx)?;
// The address of this label is the next added instruction
a.anonymous_label()?;
a.xor(rcx, rdx)?;
// Target is the `xor rcx, rdx` instruction
let anon = a.bwd()?; // Unfortunately, Rust forces us to create a local
a.je(anon)?;
// Target is the `sub eax, eax` instruction
let anon = a.fwd()?; // Unfortunately, Rust forces us to create a local
a.js(anon)?;
a.nop()?;
// Create the label referenced by `fwd()` above
a.anonymous_label()?;
a.sub(eax, eax)?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\x51\x48\x31\xD1\x74\xFB\x78\x01\x90\x29\xC0");

pub fn bwd(&mut self) -> Result<CodeLabel, IcedError>

Gets the previously created anonymous label created by anonymous_label()

Errors

Fails if no anonymous label has been created yet

pub fn fwd(&mut self) -> Result<CodeLabel, IcedError>

Gets the next anonymous label created by a future call to anonymous_label()

Errors

Fails if an error was detected

pub fn db(&mut self, data: &[u8]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.db(b"\x16\x85\x10\xA0\xFA\x9E\x11\xEB\x97\x34\x3B\x7E\xB7\x2B\x92\x63\x16\x85")?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\x16\x85\x10\xA0\xFA\x9E\x11\xEB\x97\x34\x3B\x7E\xB7\x2B\x92\x63\x16\x85\x90");

pub fn db_i(&mut self, data: &[i8]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.db_i(&[0x16, -0x7B, 0x10, -0x60, -0x06, -0x62, 0x11, -0x15, -0x69, 0x34, 0x3B, 0x7E, -0x49, 0x2B, -0x6E, 0x63, 0x16, -0x7B])?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\x16\x85\x10\xA0\xFA\x9E\x11\xEB\x97\x34\x3B\x7E\xB7\x2B\x92\x63\x16\x85\x90");

pub fn dw(&mut self, data: &[u16]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.dw(&[0x4068, 0x7956, 0xFA9F, 0x11EB, 0x9467, 0x77FA, 0x747C, 0xD088, 0x7D7E])?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\x68\x40\x56\x79\x9F\xFA\xEB\x11\x67\x94\xFA\x77\x7C\x74\x88\xD0\x7E\x7D\x90");

pub fn dw_i(&mut self, data: &[i16]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.dw_i(&[0x4068, 0x7956, -0x0561, 0x11EB, -0x6B99, 0x77FA, 0x747C, -0x2F78, 0x7D7E])?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\x68\x40\x56\x79\x9F\xFA\xEB\x11\x67\x94\xFA\x77\x7C\x74\x88\xD0\x7E\x7D\x90");

pub fn dd(&mut self, data: &[u32]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.dd(&[0x40687956, 0xFA9F11EB, 0x946777FA, 0x747CD088, 0x7D7E7C58])?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\x56\x79\x68\x40\xEB\x11\x9F\xFA\xFA\x77\x67\x94\x88\xD0\x7C\x74\x58\x7C\x7E\x7D\x90");

pub fn dd_i(&mut self, data: &[i32]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.dd_i(&[0x40687956, -0x0560EE15, -0x6B988806, 0x747CD088, 0x7D7E7C58])?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\x56\x79\x68\x40\xEB\x11\x9F\xFA\xFA\x77\x67\x94\x88\xD0\x7C\x74\x58\x7C\x7E\x7D\x90");

pub fn dd_f32(&mut self, data: &[f32]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.dd_f32(&[3.14, -1234.5678, 1e12, -3.14, 1234.5678, -1e12])?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\xC3\xF5\x48\x40\x2B\x52\x9A\xC4\xA5\xD4\x68\x53\xC3\xF5\x48\xC0\x2B\x52\x9A\x44\xA5\xD4\x68\xD3\x90");

pub fn dq(&mut self, data: &[u64]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.dq(&[0x40687956FA9F11EB, 0x946777FA747CD088, 0x7D7E7C5814C2BA6E])?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\xEB\x11\x9F\xFA\x56\x79\x68\x40\x88\xD0\x7C\x74\xFA\x77\x67\x94\x6E\xBA\xC2\x14\x58\x7C\x7E\x7D\x90");

pub fn dq_i(&mut self, data: &[i64]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.dq_i(&[0x40687956FA9F11EB, -0x6B9888058B832F78, 0x7D7E7C5814C2BA6E])?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\xEB\x11\x9F\xFA\x56\x79\x68\x40\x88\xD0\x7C\x74\xFA\x77\x67\x94\x6E\xBA\xC2\x14\x58\x7C\x7E\x7D\x90");

pub fn dq_f64(&mut self, data: &[f64]) -> Result<(), IcedError>

Adds data

Errors

Fails if an error was detected

Arguments

• data: The data that will be added at the current position

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.int3()?;
a.dq_f64(&[3.14, -1234.5678, 1e123])?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\xCC\x1F\x85\xEB\x51\xB8\x1E\x09\x40\xAD\xFA\x5C\x6D\x45\x4A\x93\xC0\xF1\x72\xF8\xA5\x25\x34\x78\x59\x90");

pub fn nops_with_size(&mut self, size: usize) -> Result<(), IcedError>

Adds nops, preferring long nops

Errors

Fails if an error was detected

Arguments

• size: Size in bytes of all nops

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.nops_with_size(17)?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes.len(), 17);

pub fn add_instruction(
    &mut self,
    instruction: Instruction
) -> Result<(), IcedError>

Adds an instruction created by the decoder or by Instruction::with*() methods

Errors

Fails if an error was detected

Arguments

• instruction: Instruction to add

Examples

use iced_x86::*;
use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
a.nop()?;
a.add_instruction(Instruction::with1(Code::Push_r64, Register::RCX)?)?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\x90\x51");

pub fn assemble(&mut self, ip: u64) -> Result<Vec<u8>, IcedError>

Encodes all added instructions and returns the result

Errors

Fails if an error was detected (eg. an invalid instruction operand)

Arguments

• ip: Base address of all instructions

Examples

use iced_x86::code_asm::*;

let mut a = CodeAssembler::new(64)?;
let mut label1 = a.create_label();
a.push(rcx)?;
// The address of this label is the next added instruction
a.set_label(&mut label1)?;
a.xor(rcx, rdx)?;
// Target is the `xor rcx, rdx` instruction
a.je(label1)?;
a.nop()?;
let bytes = a.assemble(0x1234_5678)?;
assert_eq!(bytes, b"\x51\x48\x31\xD1\x74\xFB\x90");

pub fn bitness(&self) -> u32

Gets the bitness (16, 32 or 64)

pub fn prefer_vex(&self) -> bool

true (default value) to use VEX encoding intead of EVEX encoding if we must pick one of the encodings. See also vex() and evex()

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

true (default value) to use VEX encoding intead of EVEX encoding if we must pick one of the encodings. See also vex() and evex()

Arguments

• new_value: New value

pub fn prefer_short_branch(&self) -> bool

true (default value) to create short branches, false to create near branches.

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

true (default value) to create short branches, false to create near branches.

Arguments

• new_value: New value

pub fn call_far(&mut self, selector: u16, offset: u32) -> Result<(), IcedError>

CALL FAR instruction

Instruction	Opcode	CPUID
CALL ptr16:16	o16 9A cd	8086+
CALL ptr16:32	o32 9A cp	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• selector: Selector/segment
• offset: Offset within the segment

pub fn jmp_far(&mut self, selector: u16, offset: u32) -> Result<(), IcedError>

JMP FAR instruction

Instruction	Opcode	CPUID
JMP ptr16:16	o16 EA cd	8086+
JMP ptr16:32	o32 EA cp	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• selector: Selector/segment
• offset: Offset within the segment

pub fn xlatb(&mut self) -> Result<(), IcedError>

XLATB instruction

Instruction	Opcode	CPUID
XLATB	D7	8086+

Errors

Fails if an operand is invalid (basic checks only)

impl CodeAssembler

pub fn aaa(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmAaa, 

AAA instruction

Instruction	Opcode	CPUID
AAA	37	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn aad<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmAad<T>, 

AAD instruction

Instruction	Opcode	CPUID
AAD imm8	D5 ib	8086+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn aam<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmAam<T>, 

AAM instruction

Instruction	Opcode	CPUID
AAM imm8	D4 ib	8086+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn aas(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmAas, 

AAS instruction

Instruction	Opcode	CPUID
AAS	3F	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn adc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAdc<T, U>, 

ADC instruction

Instruction	Opcode	CPUID
ADC r/m8, r8	10 /r	8086+
ADC r/m16, r16	o16 11 /r	8086+
ADC r/m32, r32	o32 11 /r	386+
ADC r/m64, r64	o64 11 /r	X64
ADC r8, r/m8	12 /r	8086+
ADC r16, r/m16	o16 13 /r	8086+
ADC r32, r/m32	o32 13 /r	386+
ADC r64, r/m64	o64 13 /r	X64
ADC AL, imm8	14 ib	8086+
ADC AX, imm16	o16 15 iw	8086+
ADC EAX, imm32	o32 15 id	386+
ADC RAX, imm32	o64 15 id	X64
ADC r/m8, imm8	80 /2 ib	8086+
ADC r/m16, imm16	o16 81 /2 iw	8086+
ADC r/m32, imm32	o32 81 /2 id	386+
ADC r/m64, imm32	o64 81 /2 id	X64
ADC r/m16, imm8	o16 83 /2 ib	8086+
ADC r/m32, imm8	o32 83 /2 ib	386+
ADC r/m64, imm8	o64 83 /2 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn adcx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAdcx<T, U>, 

ADCX instruction

Instruction	Opcode	CPUID
ADCX r32, r/m32	66 0F 38 F6 /r	ADX
ADCX r64, r/m64	66 o64 0F 38 F6 /r	ADX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn add<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAdd<T, U>, 

ADD instruction

Instruction	Opcode	CPUID
ADD r/m8, r8	00 /r	8086+
ADD r/m16, r16	o16 01 /r	8086+
ADD r/m32, r32	o32 01 /r	386+
ADD r/m64, r64	o64 01 /r	X64
ADD r8, r/m8	02 /r	8086+
ADD r16, r/m16	o16 03 /r	8086+
ADD r32, r/m32	o32 03 /r	386+
ADD r64, r/m64	o64 03 /r	X64
ADD AL, imm8	04 ib	8086+
ADD AX, imm16	o16 05 iw	8086+
ADD EAX, imm32	o32 05 id	386+
ADD RAX, imm32	o64 05 id	X64
ADD r/m8, imm8	80 /0 ib	8086+
ADD r/m16, imm16	o16 81 /0 iw	8086+
ADD r/m32, imm32	o32 81 /0 id	386+
ADD r/m64, imm32	o64 81 /0 id	X64
ADD r/m16, imm8	o16 83 /0 ib	8086+
ADD r/m32, imm8	o32 83 /0 ib	386+
ADD r/m64, imm8	o64 83 /0 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn addpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAddpd<T, U>, 

ADDPD instruction

Instruction	Opcode	CPUID
ADDPD xmm1, xmm2/m128	66 0F 58 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn addps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAddps<T, U>, 

ADDPS instruction

Instruction	Opcode	CPUID
ADDPS xmm1, xmm2/m128	NP 0F 58 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn addsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAddsd<T, U>, 

ADDSD instruction

Instruction	Opcode	CPUID
ADDSD xmm1, xmm2/m64	F2 0F 58 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn addss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAddss<T, U>, 

ADDSS instruction

Instruction	Opcode	CPUID
ADDSS xmm1, xmm2/m32	F3 0F 58 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn addsubpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAddsubpd<T, U>, 

ADDSUBPD instruction

Instruction	Opcode	CPUID
ADDSUBPD xmm1, xmm2/m128	66 0F D0 /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn addsubps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAddsubps<T, U>, 

ADDSUBPS instruction

Instruction	Opcode	CPUID
ADDSUBPS xmm1, xmm2/m128	F2 0F D0 /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn adox<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAdox<T, U>, 

ADOX instruction

Instruction	Opcode	CPUID
ADOX r32, r/m32	F3 0F 38 F6 /r	ADX
ADOX r64, r/m64	F3 o64 0F 38 F6 /r	ADX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aesdec<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAesdec<T, U>, 

AESDEC instruction

Instruction	Opcode	CPUID
AESDEC xmm1, xmm2/m128	66 0F 38 DE /r	AES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aesdec128kl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAesdec128kl<T, U>, 

AESDEC128KL instruction

Instruction	Opcode	CPUID
AESDEC128KL xmm, m384	F3 0F 38 DD !(11):rrr:bbb	AESKLE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aesdec256kl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAesdec256kl<T, U>, 

AESDEC256KL instruction

Instruction	Opcode	CPUID
AESDEC256KL xmm, m512	F3 0F 38 DF !(11):rrr:bbb	AESKLE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aesdeclast<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAesdeclast<T, U>, 

AESDECLAST instruction

Instruction	Opcode	CPUID
AESDECLAST xmm1, xmm2/m128	66 0F 38 DF /r	AES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aesdecwide128kl<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmAesdecwide128kl<T>, 

AESDECWIDE128KL instruction

Instruction	Opcode	CPUID
AESDECWIDE128KL m384, <XMM0-7>	F3 0F 38 D8 !(11):001:bbb	AESKLE WIDE_KL

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn aesdecwide256kl<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmAesdecwide256kl<T>, 

AESDECWIDE256KL instruction

Instruction	Opcode	CPUID
AESDECWIDE256KL m512, <XMM0-7>	F3 0F 38 D8 !(11):011:bbb	AESKLE WIDE_KL

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn aesenc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAesenc<T, U>, 

AESENC instruction

Instruction	Opcode	CPUID
AESENC xmm1, xmm2/m128	66 0F 38 DC /r	AES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aesenc128kl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAesenc128kl<T, U>, 

AESENC128KL instruction

Instruction	Opcode	CPUID
AESENC128KL xmm, m384	F3 0F 38 DC !(11):rrr:bbb	AESKLE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aesenc256kl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAesenc256kl<T, U>, 

AESENC256KL instruction

Instruction	Opcode	CPUID
AESENC256KL xmm, m512	F3 0F 38 DE !(11):rrr:bbb	AESKLE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aesenclast<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAesenclast<T, U>, 

AESENCLAST instruction

Instruction	Opcode	CPUID
AESENCLAST xmm1, xmm2/m128	66 0F 38 DD /r	AES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aesencwide128kl<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmAesencwide128kl<T>, 

AESENCWIDE128KL instruction

Instruction	Opcode	CPUID
AESENCWIDE128KL m384, <XMM0-7>	F3 0F 38 D8 !(11):000:bbb	AESKLE WIDE_KL

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn aesencwide256kl<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmAesencwide256kl<T>, 

AESENCWIDE256KL instruction

Instruction	Opcode	CPUID
AESENCWIDE256KL m512, <XMM0-7>	F3 0F 38 D8 !(11):010:bbb	AESKLE WIDE_KL

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn aesimc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAesimc<T, U>, 

AESIMC instruction

Instruction	Opcode	CPUID
AESIMC xmm1, xmm2/m128	66 0F 38 DB /r	AES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn aeskeygenassist<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmAeskeygenassist<T, U, V>, 

AESKEYGENASSIST instruction

Instruction	Opcode	CPUID
AESKEYGENASSIST xmm1, xmm2/m128, imm8	66 0F 3A DF /r ib	AES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn altinst(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmAltinst, 

ALTINST instruction

Instruction	Opcode	CPUID
ALTINST	0F 3F	Centaur AIS

Errors

Fails if an operand is invalid (basic checks only)

pub fn and<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAnd<T, U>, 

AND instruction

Instruction	Opcode	CPUID
AND r/m8, r8	20 /r	8086+
AND r/m16, r16	o16 21 /r	8086+
AND r/m32, r32	o32 21 /r	386+
AND r/m64, r64	o64 21 /r	X64
AND r8, r/m8	22 /r	8086+
AND r16, r/m16	o16 23 /r	8086+
AND r32, r/m32	o32 23 /r	386+
AND r64, r/m64	o64 23 /r	X64
AND AL, imm8	24 ib	8086+
AND AX, imm16	o16 25 iw	8086+
AND EAX, imm32	o32 25 id	386+
AND RAX, imm32	o64 25 id	X64
AND r/m8, imm8	80 /4 ib	8086+
AND r/m16, imm16	o16 81 /4 iw	8086+
AND r/m32, imm32	o32 81 /4 id	386+
AND r/m64, imm32	o64 81 /4 id	X64
AND r/m16, imm8	o16 83 /4 ib	8086+
AND r/m32, imm8	o32 83 /4 ib	386+
AND r/m64, imm8	o64 83 /4 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn andn<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmAndn<T, U, V>, 

ANDN instruction

Instruction	Opcode	CPUID
ANDN r32a, r32b, r/m32	VEX.LZ.0F38.W0 F2 /r	BMI1
ANDN r64a, r64b, r/m64	VEX.LZ.0F38.W1 F2 /r	BMI1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn andnpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAndnpd<T, U>, 

ANDNPD instruction

Instruction	Opcode	CPUID
ANDNPD xmm1, xmm2/m128	66 0F 55 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn andnps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAndnps<T, U>, 

ANDNPS instruction

Instruction	Opcode	CPUID
ANDNPS xmm1, xmm2/m128	NP 0F 55 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn andpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAndpd<T, U>, 

ANDPD instruction

Instruction	Opcode	CPUID
ANDPD xmm1, xmm2/m128	66 0F 54 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn andps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmAndps<T, U>, 

ANDPS instruction

Instruction	Opcode	CPUID
ANDPS xmm1, xmm2/m128	NP 0F 54 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn arpl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmArpl<T, U>, 

ARPL instruction

Instruction	Opcode	CPUID
ARPL r/m16, r16	o16 63 /r	286+
ARPL r32/m16, r32	o32 63 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bb0_reset(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmBb0_reset, 

BB0_RESET instruction

Instruction	Opcode	CPUID
BB0_RESET	0F 3A	Cyrix MediaGX, GXm, GXLV, GX1

Errors

Fails if an operand is invalid (basic checks only)

pub fn bb1_reset(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmBb1_reset, 

BB1_RESET instruction

Instruction	Opcode	CPUID
BB1_RESET	0F 3B	Cyrix MediaGX, GXm, GXLV, GX1

Errors

Fails if an operand is invalid (basic checks only)

pub fn bextr<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmBextr<T, U, V>, 

BEXTR instruction

Instruction	Opcode	CPUID
BEXTR r32a, r/m32, r32b	VEX.LZ.0F38.W0 F7 /r	BMI1
BEXTR r64a, r/m64, r64b	VEX.LZ.0F38.W1 F7 /r	BMI1
BEXTR r32, r/m32, imm32	XOP.L0.XA.W0 10 /r id	TBM
BEXTR r64, r/m64, imm32	XOP.L0.XA.W1 10 /r id	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn blcfill<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlcfill<T, U>, 

BLCFILL instruction

Instruction	Opcode	CPUID
BLCFILL r32, r/m32	XOP.L0.X9.W0 01 /1	TBM
BLCFILL r64, r/m64	XOP.L0.X9.W1 01 /1	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blci<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlci<T, U>, 

BLCI instruction

Instruction	Opcode	CPUID
BLCI r32, r/m32	XOP.L0.X9.W0 02 /6	TBM
BLCI r64, r/m64	XOP.L0.X9.W1 02 /6	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blcic<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlcic<T, U>, 

BLCIC instruction

Instruction	Opcode	CPUID
BLCIC r32, r/m32	XOP.L0.X9.W0 01 /5	TBM
BLCIC r64, r/m64	XOP.L0.X9.W1 01 /5	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blcmsk<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlcmsk<T, U>, 

BLCMSK instruction

Instruction	Opcode	CPUID
BLCMSK r32, r/m32	XOP.L0.X9.W0 02 /1	TBM
BLCMSK r64, r/m64	XOP.L0.X9.W1 02 /1	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blcs<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlcs<T, U>, 

BLCS instruction

Instruction	Opcode	CPUID
BLCS r32, r/m32	XOP.L0.X9.W0 01 /3	TBM
BLCS r64, r/m64	XOP.L0.X9.W1 01 /3	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blendpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmBlendpd<T, U, V>, 

BLENDPD instruction

Instruction	Opcode	CPUID
BLENDPD xmm1, xmm2/m128, imm8	66 0F 3A 0D /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn blendps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmBlendps<T, U, V>, 

BLENDPS instruction

Instruction	Opcode	CPUID
BLENDPS xmm1, xmm2/m128, imm8	66 0F 3A 0C /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn blendvpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlendvpd<T, U>, 

BLENDVPD instruction

Instruction	Opcode	CPUID
BLENDVPD xmm1, xmm2/m128, <XMM0>	66 0F 38 15 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blendvps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlendvps<T, U>, 

BLENDVPS instruction

Instruction	Opcode	CPUID
BLENDVPS xmm1, xmm2/m128, <XMM0>	66 0F 38 14 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blsfill<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlsfill<T, U>, 

BLSFILL instruction

Instruction	Opcode	CPUID
BLSFILL r32, r/m32	XOP.L0.X9.W0 01 /2	TBM
BLSFILL r64, r/m64	XOP.L0.X9.W1 01 /2	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blsi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlsi<T, U>, 

BLSI instruction

Instruction	Opcode	CPUID
BLSI r32, r/m32	VEX.LZ.0F38.W0 F3 /3	BMI1
BLSI r64, r/m64	VEX.LZ.0F38.W1 F3 /3	BMI1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blsic<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlsic<T, U>, 

BLSIC instruction

Instruction	Opcode	CPUID
BLSIC r32, r/m32	XOP.L0.X9.W0 01 /6	TBM
BLSIC r64, r/m64	XOP.L0.X9.W1 01 /6	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blsmsk<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlsmsk<T, U>, 

BLSMSK instruction

Instruction	Opcode	CPUID
BLSMSK r32, r/m32	VEX.LZ.0F38.W0 F3 /2	BMI1
BLSMSK r64, r/m64	VEX.LZ.0F38.W1 F3 /2	BMI1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn blsr<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBlsr<T, U>, 

BLSR instruction

Instruction	Opcode	CPUID
BLSR r32, r/m32	VEX.LZ.0F38.W0 F3 /1	BMI1
BLSR r64, r/m64	VEX.LZ.0F38.W1 F3 /1	BMI1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bndcl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBndcl<T, U>, 

BNDCL instruction

Instruction	Opcode	CPUID
BNDCL bnd, r/m32	F3 0F 1A /r	MPX
BNDCL bnd, r/m64	F3 0F 1A /r	MPX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bndcn<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBndcn<T, U>, 

BNDCN instruction

Instruction	Opcode	CPUID
BNDCN bnd, r/m32	F2 0F 1B /r	MPX
BNDCN bnd, r/m64	F2 0F 1B /r	MPX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bndcu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBndcu<T, U>, 

BNDCU instruction

Instruction	Opcode	CPUID
BNDCU bnd, r/m32	F2 0F 1A /r	MPX
BNDCU bnd, r/m64	F2 0F 1A /r	MPX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bndldx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBndldx<T, U>, 

BNDLDX instruction

Instruction	Opcode	CPUID
BNDLDX bnd, mib	NP 0F 1A /r	MPX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bndmk<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBndmk<T, U>, 

BNDMK instruction

Instruction	Opcode	CPUID
BNDMK bnd, m32	F3 0F 1B /r	MPX
BNDMK bnd, m64	F3 0F 1B /r	MPX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bndmov<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBndmov<T, U>, 

BNDMOV instruction

Instruction	Opcode	CPUID
BNDMOV bnd1, bnd2/m64	66 0F 1A /r	MPX
BNDMOV bnd1, bnd2/m128	66 0F 1A /r	MPX
BNDMOV bnd1/m64, bnd2	66 0F 1B /r	MPX
BNDMOV bnd1/m128, bnd2	66 0F 1B /r	MPX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bndstx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBndstx<T, U>, 

BNDSTX instruction

Instruction	Opcode	CPUID
BNDSTX mib, bnd	NP 0F 1B /r	MPX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bound<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBound<T, U>, 

BOUND instruction

Instruction	Opcode	CPUID
BOUND r16, m16&16	o16 62 /r	186+
BOUND r32, m32&32	o32 62 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bsf<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBsf<T, U>, 

BSF instruction

Instruction	Opcode	CPUID
BSF r16, r/m16	o16 0F BC /r	386+
BSF r32, r/m32	o32 0F BC /r	386+
BSF r64, r/m64	o64 0F BC /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bsr<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBsr<T, U>, 

BSR instruction

Instruction	Opcode	CPUID
BSR r16, r/m16	o16 0F BD /r	386+
BSR r32, r/m32	o32 0F BD /r	386+
BSR r64, r/m64	o64 0F BD /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bswap<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmBswap<T>, 

BSWAP instruction

Instruction	Opcode	CPUID
BSWAP r16	o16 0F C8+rw	486+
BSWAP r32	o32 0F C8+rd	486+
BSWAP r64	o64 0F C8+ro	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn bt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBt<T, U>, 

BT instruction

Instruction	Opcode	CPUID
BT r/m16, r16	o16 0F A3 /r	386+
BT r/m32, r32	o32 0F A3 /r	386+
BT r/m64, r64	o64 0F A3 /r	X64
BT r/m16, imm8	o16 0F BA /4 ib	386+
BT r/m32, imm8	o32 0F BA /4 ib	386+
BT r/m64, imm8	o64 0F BA /4 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn btc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBtc<T, U>, 

BTC instruction

Instruction	Opcode	CPUID
BTC r/m16, imm8	o16 0F BA /7 ib	386+
BTC r/m32, imm8	o32 0F BA /7 ib	386+
BTC r/m64, imm8	o64 0F BA /7 ib	X64
BTC r/m16, r16	o16 0F BB /r	386+
BTC r/m32, r32	o32 0F BB /r	386+
BTC r/m64, r64	o64 0F BB /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn btr<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBtr<T, U>, 

BTR instruction

Instruction	Opcode	CPUID
BTR r/m16, r16	o16 0F B3 /r	386+
BTR r/m32, r32	o32 0F B3 /r	386+
BTR r/m64, r64	o64 0F B3 /r	X64
BTR r/m16, imm8	o16 0F BA /6 ib	386+
BTR r/m32, imm8	o32 0F BA /6 ib	386+
BTR r/m64, imm8	o64 0F BA /6 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bts<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmBts<T, U>, 

BTS instruction

Instruction	Opcode	CPUID
BTS r/m16, r16	o16 0F AB /r	386+
BTS r/m32, r32	o32 0F AB /r	386+
BTS r/m64, r64	o64 0F AB /r	X64
BTS r/m16, imm8	o16 0F BA /5 ib	386+
BTS r/m32, imm8	o32 0F BA /5 ib	386+
BTS r/m64, imm8	o64 0F BA /5 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn bzhi<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmBzhi<T, U, V>, 

BZHI instruction

Instruction	Opcode	CPUID
BZHI r32a, r/m32, r32b	VEX.LZ.0F38.W0 F5 /r	BMI2
BZHI r64a, r/m64, r64b	VEX.LZ.0F38.W1 F5 /r	BMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn call<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmCall<T>, 

CALL instruction

Instruction	Opcode	CPUID
CALL rel16	o16 E8 cw	8086+
CALL rel32	o32 E8 cd	386+
CALL rel32	o64 E8 cd	X64
CALL r/m16	o16 FF /2	8086+
CALL r/m32	o32 FF /2	386+
CALL r/m64	o64 FF /2	X64
CALL m16:16	o16 FF /3	8086+
CALL m16:32	o32 FF /3	386+
CALL m16:64	o64 FF /3	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn cbw(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCbw, 

CBW instruction

Instruction	Opcode	CPUID
CBW	o16 98	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn ccs_encrypt(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCcs_encrypt, 

CCS_ENCRYPT instruction

Instruction	Opcode	CPUID
CCS_ENCRYPT	a16 F3 0F A7 F0	PADLOCK_GMI
CCS_ENCRYPT	a32 F3 0F A7 F0	PADLOCK_GMI
CCS_ENCRYPT	a64 F3 0F A7 F0	PADLOCK_GMI

Errors

Fails if an operand is invalid (basic checks only)

pub fn ccs_hash(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCcs_hash, 

CCS_HASH instruction

Instruction	Opcode	CPUID
CCS_HASH	a16 F3 0F A6 E8	PADLOCK_GMI
CCS_HASH	a32 F3 0F A6 E8	PADLOCK_GMI
CCS_HASH	a64 F3 0F A6 E8	PADLOCK_GMI

Errors

Fails if an operand is invalid (basic checks only)

pub fn cdq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCdq, 

CDQ instruction

Instruction	Opcode	CPUID
CDQ	o32 99	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn cdqe(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCdqe, 

CDQE instruction

Instruction	Opcode	CPUID
CDQE	o64 98	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn cl1invmb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCl1invmb, 

CL1INVMB instruction

Instruction	Opcode	CPUID
CL1INVMB	0F 0A	CL1INVMB

Errors

Fails if an operand is invalid (basic checks only)

pub fn clac(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmClac, 

CLAC instruction

Instruction	Opcode	CPUID
CLAC	NP 0F 01 CA	SMAP

Errors

Fails if an operand is invalid (basic checks only)

pub fn clc(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmClc, 

CLC instruction

Instruction	Opcode	CPUID
CLC	F8	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn cld(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCld, 

CLD instruction

Instruction	Opcode	CPUID
CLD	FC	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn cldemote<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmCldemote<T>, 

CLDEMOTE instruction

Instruction	Opcode	CPUID
CLDEMOTE m8	NP 0F 1C /0	CLDEMOTE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn clflush<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmClflush<T>, 

CLFLUSH instruction

Instruction	Opcode	CPUID
CLFLUSH m8	NP 0F AE /7	CLFSH

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn clflushopt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmClflushopt<T>, 

CLFLUSHOPT instruction

Instruction	Opcode	CPUID
CLFLUSHOPT m8	66 0F AE /7	CLFLUSHOPT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn clgi(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmClgi, 

CLGI instruction

Instruction	Opcode	CPUID
CLGI	0F 01 DD	SVM

Errors

Fails if an operand is invalid (basic checks only)

pub fn cli(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCli, 

CLI instruction

Instruction	Opcode	CPUID
CLI	FA	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn clrssbsy<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmClrssbsy<T>, 

CLRSSBSY instruction

Instruction	Opcode	CPUID
CLRSSBSY m64	F3 0F AE /6	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn clts(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmClts, 

CLTS instruction

Instruction	Opcode	CPUID
CLTS	0F 06	286+

Errors

Fails if an operand is invalid (basic checks only)

pub fn clui(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmClui, 

CLUI instruction

Instruction	Opcode	CPUID
CLUI	F3 0F 01 EE	UINTR

Errors

Fails if an operand is invalid (basic checks only)

pub fn clwb<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmClwb<T>, 

CLWB instruction

Instruction	Opcode	CPUID
CLWB m8	66 0F AE /6	CLWB

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn clzero(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmClzero, 

CLZERO instruction

Instruction	Opcode	CPUID
CLZERO	a16 0F 01 FC	CLZERO
CLZERO	a32 0F 01 FC	CLZERO
CLZERO	a64 0F 01 FC	CLZERO

Errors

Fails if an operand is invalid (basic checks only)

pub fn cmc(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCmc, 

CMC instruction

Instruction	Opcode	CPUID
CMC	F5	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn cmova<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmova<T, U>, 

CMOVA instruction

Instruction	Opcode	CPUID
CMOVA r16, r/m16	o16 0F 47 /r	CMOV
CMOVA r32, r/m32	o32 0F 47 /r	CMOV
CMOVA r64, r/m64	o64 0F 47 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovae<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovae<T, U>, 

CMOVAE instruction

Instruction	Opcode	CPUID
CMOVAE r16, r/m16	o16 0F 43 /r	CMOV
CMOVAE r32, r/m32	o32 0F 43 /r	CMOV
CMOVAE r64, r/m64	o64 0F 43 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovb<T, U>, 

CMOVB instruction

Instruction	Opcode	CPUID
CMOVB r16, r/m16	o16 0F 42 /r	CMOV
CMOVB r32, r/m32	o32 0F 42 /r	CMOV
CMOVB r64, r/m64	o64 0F 42 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovbe<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovbe<T, U>, 

CMOVBE instruction

Instruction	Opcode	CPUID
CMOVBE r16, r/m16	o16 0F 46 /r	CMOV
CMOVBE r32, r/m32	o32 0F 46 /r	CMOV
CMOVBE r64, r/m64	o64 0F 46 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovc<T, U>, 

CMOVC instruction

Instruction	Opcode	CPUID
CMOVB r16, r/m16	o16 0F 42 /r	CMOV
CMOVB r32, r/m32	o32 0F 42 /r	CMOV
CMOVB r64, r/m64	o64 0F 42 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmove<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmove<T, U>, 

CMOVE instruction

Instruction	Opcode	CPUID
CMOVE r16, r/m16	o16 0F 44 /r	CMOV
CMOVE r32, r/m32	o32 0F 44 /r	CMOV
CMOVE r64, r/m64	o64 0F 44 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovg<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovg<T, U>, 

CMOVG instruction

Instruction	Opcode	CPUID
CMOVG r16, r/m16	o16 0F 4F /r	CMOV
CMOVG r32, r/m32	o32 0F 4F /r	CMOV
CMOVG r64, r/m64	o64 0F 4F /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovge<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovge<T, U>, 

CMOVGE instruction

Instruction	Opcode	CPUID
CMOVGE r16, r/m16	o16 0F 4D /r	CMOV
CMOVGE r32, r/m32	o32 0F 4D /r	CMOV
CMOVGE r64, r/m64	o64 0F 4D /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovl<T, U>, 

CMOVL instruction

Instruction	Opcode	CPUID
CMOVL r16, r/m16	o16 0F 4C /r	CMOV
CMOVL r32, r/m32	o32 0F 4C /r	CMOV
CMOVL r64, r/m64	o64 0F 4C /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovle<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovle<T, U>, 

CMOVLE instruction

Instruction	Opcode	CPUID
CMOVLE r16, r/m16	o16 0F 4E /r	CMOV
CMOVLE r32, r/m32	o32 0F 4E /r	CMOV
CMOVLE r64, r/m64	o64 0F 4E /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovna<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovna<T, U>, 

CMOVNA instruction

Instruction	Opcode	CPUID
CMOVBE r16, r/m16	o16 0F 46 /r	CMOV
CMOVBE r32, r/m32	o32 0F 46 /r	CMOV
CMOVBE r64, r/m64	o64 0F 46 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovnae<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovnae<T, U>, 

CMOVNAE instruction

Instruction	Opcode	CPUID
CMOVB r16, r/m16	o16 0F 42 /r	CMOV
CMOVB r32, r/m32	o32 0F 42 /r	CMOV
CMOVB r64, r/m64	o64 0F 42 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovnb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovnb<T, U>, 

CMOVNB instruction

Instruction	Opcode	CPUID
CMOVAE r16, r/m16	o16 0F 43 /r	CMOV
CMOVAE r32, r/m32	o32 0F 43 /r	CMOV
CMOVAE r64, r/m64	o64 0F 43 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovnbe<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovnbe<T, U>, 

CMOVNBE instruction

Instruction	Opcode	CPUID
CMOVA r16, r/m16	o16 0F 47 /r	CMOV
CMOVA r32, r/m32	o32 0F 47 /r	CMOV
CMOVA r64, r/m64	o64 0F 47 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovnc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovnc<T, U>, 

CMOVNC instruction

Instruction	Opcode	CPUID
CMOVAE r16, r/m16	o16 0F 43 /r	CMOV
CMOVAE r32, r/m32	o32 0F 43 /r	CMOV
CMOVAE r64, r/m64	o64 0F 43 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovne<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovne<T, U>, 

CMOVNE instruction

Instruction	Opcode	CPUID
CMOVNE r16, r/m16	o16 0F 45 /r	CMOV
CMOVNE r32, r/m32	o32 0F 45 /r	CMOV
CMOVNE r64, r/m64	o64 0F 45 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovng<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovng<T, U>, 

CMOVNG instruction

Instruction	Opcode	CPUID
CMOVLE r16, r/m16	o16 0F 4E /r	CMOV
CMOVLE r32, r/m32	o32 0F 4E /r	CMOV
CMOVLE r64, r/m64	o64 0F 4E /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovnge<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovnge<T, U>, 

CMOVNGE instruction

Instruction	Opcode	CPUID
CMOVL r16, r/m16	o16 0F 4C /r	CMOV
CMOVL r32, r/m32	o32 0F 4C /r	CMOV
CMOVL r64, r/m64	o64 0F 4C /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovnl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovnl<T, U>, 

CMOVNL instruction

Instruction	Opcode	CPUID
CMOVGE r16, r/m16	o16 0F 4D /r	CMOV
CMOVGE r32, r/m32	o32 0F 4D /r	CMOV
CMOVGE r64, r/m64	o64 0F 4D /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovnle<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovnle<T, U>, 

CMOVNLE instruction

Instruction	Opcode	CPUID
CMOVG r16, r/m16	o16 0F 4F /r	CMOV
CMOVG r32, r/m32	o32 0F 4F /r	CMOV
CMOVG r64, r/m64	o64 0F 4F /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovno<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovno<T, U>, 

CMOVNO instruction

Instruction	Opcode	CPUID
CMOVNO r16, r/m16	o16 0F 41 /r	CMOV
CMOVNO r32, r/m32	o32 0F 41 /r	CMOV
CMOVNO r64, r/m64	o64 0F 41 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovnp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovnp<T, U>, 

CMOVNP instruction

Instruction	Opcode	CPUID
CMOVNP r16, r/m16	o16 0F 4B /r	CMOV
CMOVNP r32, r/m32	o32 0F 4B /r	CMOV
CMOVNP r64, r/m64	o64 0F 4B /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovns<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovns<T, U>, 

CMOVNS instruction

Instruction	Opcode	CPUID
CMOVNS r16, r/m16	o16 0F 49 /r	CMOV
CMOVNS r32, r/m32	o32 0F 49 /r	CMOV
CMOVNS r64, r/m64	o64 0F 49 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovnz<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovnz<T, U>, 

CMOVNZ instruction

Instruction	Opcode	CPUID
CMOVNE r16, r/m16	o16 0F 45 /r	CMOV
CMOVNE r32, r/m32	o32 0F 45 /r	CMOV
CMOVNE r64, r/m64	o64 0F 45 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovo<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovo<T, U>, 

CMOVO instruction

Instruction	Opcode	CPUID
CMOVO r16, r/m16	o16 0F 40 /r	CMOV
CMOVO r32, r/m32	o32 0F 40 /r	CMOV
CMOVO r64, r/m64	o64 0F 40 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovp<T, U>, 

CMOVP instruction

Instruction	Opcode	CPUID
CMOVP r16, r/m16	o16 0F 4A /r	CMOV
CMOVP r32, r/m32	o32 0F 4A /r	CMOV
CMOVP r64, r/m64	o64 0F 4A /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovpe<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovpe<T, U>, 

CMOVPE instruction

Instruction	Opcode	CPUID
CMOVP r16, r/m16	o16 0F 4A /r	CMOV
CMOVP r32, r/m32	o32 0F 4A /r	CMOV
CMOVP r64, r/m64	o64 0F 4A /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovpo<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovpo<T, U>, 

CMOVPO instruction

Instruction	Opcode	CPUID
CMOVNP r16, r/m16	o16 0F 4B /r	CMOV
CMOVNP r32, r/m32	o32 0F 4B /r	CMOV
CMOVNP r64, r/m64	o64 0F 4B /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovs<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovs<T, U>, 

CMOVS instruction

Instruction	Opcode	CPUID
CMOVS r16, r/m16	o16 0F 48 /r	CMOV
CMOVS r32, r/m32	o32 0F 48 /r	CMOV
CMOVS r64, r/m64	o64 0F 48 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmovz<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmovz<T, U>, 

CMOVZ instruction

Instruction	Opcode	CPUID
CMOVE r16, r/m16	o16 0F 44 /r	CMOV
CMOVE r32, r/m32	o32 0F 44 /r	CMOV
CMOVE r64, r/m64	o64 0F 44 /r	CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmp<T, U>, 

CMP instruction

Instruction	Opcode	CPUID
CMP r/m8, r8	38 /r	8086+
CMP r/m16, r16	o16 39 /r	8086+
CMP r/m32, r32	o32 39 /r	386+
CMP r/m64, r64	o64 39 /r	X64
CMP r8, r/m8	3A /r	8086+
CMP r16, r/m16	o16 3B /r	8086+
CMP r32, r/m32	o32 3B /r	386+
CMP r64, r/m64	o64 3B /r	X64
CMP AL, imm8	3C ib	8086+
CMP AX, imm16	o16 3D iw	8086+
CMP EAX, imm32	o32 3D id	386+
CMP RAX, imm32	o64 3D id	X64
CMP r/m8, imm8	80 /7 ib	8086+
CMP r/m16, imm16	o16 81 /7 iw	8086+
CMP r/m32, imm32	o32 81 /7 id	386+
CMP r/m64, imm32	o64 81 /7 id	X64
CMP r/m16, imm8	o16 83 /7 ib	8086+
CMP r/m32, imm8	o32 83 /7 ib	386+
CMP r/m64, imm8	o64 83 /7 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpeqpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpeqpd<T, U>, 

CMPEQPD instruction

Instruction	Opcode	CPUID
CMPPD xmm1, xmm2/m128, imm8	66 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpeqps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpeqps<T, U>, 

CMPEQPS instruction

Instruction	Opcode	CPUID
CMPPS xmm1, xmm2/m128, imm8	NP 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpeqsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpeqsd<T, U>, 

CMPEQSD instruction

Instruction	Opcode	CPUID
CMPSD xmm1, xmm2/m64, imm8	F2 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpeqss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpeqss<T, U>, 

CMPEQSS instruction

Instruction	Opcode	CPUID
CMPSS xmm1, xmm2/m32, imm8	F3 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmplepd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmplepd<T, U>, 

CMPLEPD instruction

Instruction	Opcode	CPUID
CMPPD xmm1, xmm2/m128, imm8	66 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpleps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpleps<T, U>, 

CMPLEPS instruction

Instruction	Opcode	CPUID
CMPPS xmm1, xmm2/m128, imm8	NP 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmplesd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmplesd<T, U>, 

CMPLESD instruction

Instruction	Opcode	CPUID
CMPSD xmm1, xmm2/m64, imm8	F2 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpless<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpless<T, U>, 

CMPLESS instruction

Instruction	Opcode	CPUID
CMPSS xmm1, xmm2/m32, imm8	F3 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpltpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpltpd<T, U>, 

CMPLTPD instruction

Instruction	Opcode	CPUID
CMPPD xmm1, xmm2/m128, imm8	66 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpltps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpltps<T, U>, 

CMPLTPS instruction

Instruction	Opcode	CPUID
CMPPS xmm1, xmm2/m128, imm8	NP 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpltsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpltsd<T, U>, 

CMPLTSD instruction

Instruction	Opcode	CPUID
CMPSD xmm1, xmm2/m64, imm8	F2 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpltss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpltss<T, U>, 

CMPLTSS instruction

Instruction	Opcode	CPUID
CMPSS xmm1, xmm2/m32, imm8	F3 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpneqpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpneqpd<T, U>, 

CMPNEQPD instruction

Instruction	Opcode	CPUID
CMPPD xmm1, xmm2/m128, imm8	66 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpneqps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpneqps<T, U>, 

CMPNEQPS instruction

Instruction	Opcode	CPUID
CMPPS xmm1, xmm2/m128, imm8	NP 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpneqsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpneqsd<T, U>, 

CMPNEQSD instruction

Instruction	Opcode	CPUID
CMPSD xmm1, xmm2/m64, imm8	F2 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpneqss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpneqss<T, U>, 

CMPNEQSS instruction

Instruction	Opcode	CPUID
CMPSS xmm1, xmm2/m32, imm8	F3 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpnlepd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpnlepd<T, U>, 

CMPNLEPD instruction

Instruction	Opcode	CPUID
CMPPD xmm1, xmm2/m128, imm8	66 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpnleps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpnleps<T, U>, 

CMPNLEPS instruction

Instruction	Opcode	CPUID
CMPPS xmm1, xmm2/m128, imm8	NP 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpnlesd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpnlesd<T, U>, 

CMPNLESD instruction

Instruction	Opcode	CPUID
CMPSD xmm1, xmm2/m64, imm8	F2 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpnless<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpnless<T, U>, 

CMPNLESS instruction

Instruction	Opcode	CPUID
CMPSS xmm1, xmm2/m32, imm8	F3 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpnltpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpnltpd<T, U>, 

CMPNLTPD instruction

Instruction	Opcode	CPUID
CMPPD xmm1, xmm2/m128, imm8	66 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpnltps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpnltps<T, U>, 

CMPNLTPS instruction

Instruction	Opcode	CPUID
CMPPS xmm1, xmm2/m128, imm8	NP 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpnltsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpnltsd<T, U>, 

CMPNLTSD instruction

Instruction	Opcode	CPUID
CMPSD xmm1, xmm2/m64, imm8	F2 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpnltss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpnltss<T, U>, 

CMPNLTSS instruction

Instruction	Opcode	CPUID
CMPSS xmm1, xmm2/m32, imm8	F3 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpordpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpordpd<T, U>, 

CMPORDPD instruction

Instruction	Opcode	CPUID
CMPPD xmm1, xmm2/m128, imm8	66 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpordps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpordps<T, U>, 

CMPORDPS instruction

Instruction	Opcode	CPUID
CMPPS xmm1, xmm2/m128, imm8	NP 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpordsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpordsd<T, U>, 

CMPORDSD instruction

Instruction	Opcode	CPUID
CMPSD xmm1, xmm2/m64, imm8	F2 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpordss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpordss<T, U>, 

CMPORDSS instruction

Instruction	Opcode	CPUID
CMPSS xmm1, xmm2/m32, imm8	F3 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmppd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmCmppd<T, U, V>, 

CMPPD instruction

Instruction	Opcode	CPUID
CMPPD xmm1, xmm2/m128, imm8	66 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn cmpps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmCmpps<T, U, V>, 

CMPPS instruction

Instruction	Opcode	CPUID
CMPPS xmm1, xmm2/m128, imm8	NP 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn cmpsb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCmpsb, 

CMPSB instruction

Instruction	Opcode	CPUID
CMPSB	A6	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn cmpsd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCmpsd, 

CMPSD instruction

Instruction	Opcode	CPUID
CMPSD	o32 A7	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn cmpsd_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmCmpsd3<T, U, V>, 

CMPSD instruction

Instruction	Opcode	CPUID
CMPSD xmm1, xmm2/m64, imm8	F2 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn cmpsq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCmpsq, 

CMPSQ instruction

Instruction	Opcode	CPUID
CMPSQ	o64 A7	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn cmpss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmCmpss<T, U, V>, 

CMPSS instruction

Instruction	Opcode	CPUID
CMPSS xmm1, xmm2/m32, imm8	F3 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn cmpsw(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCmpsw, 

CMPSW instruction

Instruction	Opcode	CPUID
CMPSW	o16 A7	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn cmpunordpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpunordpd<T, U>, 

CMPUNORDPD instruction

Instruction	Opcode	CPUID
CMPPD xmm1, xmm2/m128, imm8	66 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpunordps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpunordps<T, U>, 

CMPUNORDPS instruction

Instruction	Opcode	CPUID
CMPPS xmm1, xmm2/m128, imm8	NP 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpunordsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpunordsd<T, U>, 

CMPUNORDSD instruction

Instruction	Opcode	CPUID
CMPSD xmm1, xmm2/m64, imm8	F2 0F C2 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpunordss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpunordss<T, U>, 

CMPUNORDSS instruction

Instruction	Opcode	CPUID
CMPSS xmm1, xmm2/m32, imm8	F3 0F C2 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpxchg<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCmpxchg<T, U>, 

CMPXCHG instruction

Instruction	Opcode	CPUID
CMPXCHG r/m8, r8	0F B0 /r	486+
CMPXCHG r/m16, r16	o16 0F B1 /r	486+
CMPXCHG r/m32, r32	o32 0F B1 /r	486+
CMPXCHG r/m64, r64	o64 0F B1 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cmpxchg16b<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmCmpxchg16b<T>, 

CMPXCHG16B instruction

Instruction	Opcode	CPUID
CMPXCHG16B m128	o64 0F C7 /1	CMPXCHG16B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn cmpxchg8b<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmCmpxchg8b<T>, 

CMPXCHG8B instruction

Instruction	Opcode	CPUID
CMPXCHG8B m64	0F C7 /1	CX8

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn comisd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmComisd<T, U>, 

COMISD instruction

Instruction	Opcode	CPUID
COMISD xmm1, xmm2/m64	66 0F 2F /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn comiss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmComiss<T, U>, 

COMISS instruction

Instruction	Opcode	CPUID
COMISS xmm1, xmm2/m32	NP 0F 2F /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cpu_read(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCpu_read, 

CPU_READ instruction

Instruction	Opcode	CPUID
CPU_READ	0F 3D	Cyrix MediaGX, GXm, GXLV, GX1

Errors

Fails if an operand is invalid (basic checks only)

pub fn cpu_write(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCpu_write, 

CPU_WRITE instruction

Instruction	Opcode	CPUID
CPU_WRITE	0F 3C	Cyrix MediaGX, GXm, GXLV, GX1

Errors

Fails if an operand is invalid (basic checks only)

pub fn cpuid(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCpuid, 

CPUID instruction

Instruction	Opcode	CPUID
CPUID	0F A2	CPUID

Errors

Fails if an operand is invalid (basic checks only)

pub fn cqo(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCqo, 

CQO instruction

Instruction	Opcode	CPUID
CQO	o64 99	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn crc32<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCrc32<T, U>, 

CRC32 instruction

Instruction	Opcode	CPUID
CRC32 r32, r/m8	F2 0F 38 F0 /r	SSE4.2
CRC32 r64, r/m8	F2 o64 0F 38 F0 /r	SSE4.2
CRC32 r32, r/m16	o16 F2 0F 38 F1 /r	SSE4.2
CRC32 r32, r/m32	o32 F2 0F 38 F1 /r	SSE4.2
CRC32 r64, r/m64	F2 o64 0F 38 F1 /r	SSE4.2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtdq2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtdq2pd<T, U>, 

CVTDQ2PD instruction

Instruction	Opcode	CPUID
CVTDQ2PD xmm1, xmm2/m64	F3 0F E6 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtdq2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtdq2ps<T, U>, 

CVTDQ2PS instruction

Instruction	Opcode	CPUID
CVTDQ2PS xmm1, xmm2/m128	NP 0F 5B /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtpd2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtpd2dq<T, U>, 

CVTPD2DQ instruction

Instruction	Opcode	CPUID
CVTPD2DQ xmm1, xmm2/m128	F2 0F E6 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtpd2pi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtpd2pi<T, U>, 

CVTPD2PI instruction

Instruction	Opcode	CPUID
CVTPD2PI mm, xmm/m128	66 0F 2D /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtpd2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtpd2ps<T, U>, 

CVTPD2PS instruction

Instruction	Opcode	CPUID
CVTPD2PS xmm1, xmm2/m128	66 0F 5A /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtpi2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtpi2pd<T, U>, 

CVTPI2PD instruction

Instruction	Opcode	CPUID
CVTPI2PD xmm, mm/m64	66 0F 2A /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtpi2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtpi2ps<T, U>, 

CVTPI2PS instruction

Instruction	Opcode	CPUID
CVTPI2PS xmm, mm/m64	NP 0F 2A /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtps2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtps2dq<T, U>, 

CVTPS2DQ instruction

Instruction	Opcode	CPUID
CVTPS2DQ xmm1, xmm2/m128	66 0F 5B /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtps2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtps2pd<T, U>, 

CVTPS2PD instruction

Instruction	Opcode	CPUID
CVTPS2PD xmm1, xmm2/m64	NP 0F 5A /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtps2pi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtps2pi<T, U>, 

CVTPS2PI instruction

Instruction	Opcode	CPUID
CVTPS2PI mm, xmm/m64	NP 0F 2D /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtsd2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtsd2si<T, U>, 

CVTSD2SI instruction

Instruction	Opcode	CPUID
CVTSD2SI r32, xmm1/m64	F2 0F 2D /r	SSE2
CVTSD2SI r64, xmm1/m64	F2 o64 0F 2D /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtsd2ss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtsd2ss<T, U>, 

CVTSD2SS instruction

Instruction	Opcode	CPUID
CVTSD2SS xmm1, xmm2/m64	F2 0F 5A /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtsi2sd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtsi2sd<T, U>, 

CVTSI2SD instruction

Instruction	Opcode	CPUID
CVTSI2SD xmm1, r/m32	F2 0F 2A /r	SSE2
CVTSI2SD xmm1, r/m64	F2 o64 0F 2A /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtsi2ss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtsi2ss<T, U>, 

CVTSI2SS instruction

Instruction	Opcode	CPUID
CVTSI2SS xmm1, r/m32	F3 0F 2A /r	SSE
CVTSI2SS xmm1, r/m64	F3 o64 0F 2A /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtss2sd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtss2sd<T, U>, 

CVTSS2SD instruction

Instruction	Opcode	CPUID
CVTSS2SD xmm1, xmm2/m32	F3 0F 5A /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvtss2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvtss2si<T, U>, 

CVTSS2SI instruction

Instruction	Opcode	CPUID
CVTSS2SI r32, xmm1/m32	F3 0F 2D /r	SSE
CVTSS2SI r64, xmm1/m32	F3 o64 0F 2D /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvttpd2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvttpd2dq<T, U>, 

CVTTPD2DQ instruction

Instruction	Opcode	CPUID
CVTTPD2DQ xmm1, xmm2/m128	66 0F E6 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvttpd2pi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvttpd2pi<T, U>, 

CVTTPD2PI instruction

Instruction	Opcode	CPUID
CVTTPD2PI mm, xmm/m128	66 0F 2C /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvttps2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvttps2dq<T, U>, 

CVTTPS2DQ instruction

Instruction	Opcode	CPUID
CVTTPS2DQ xmm1, xmm2/m128	F3 0F 5B /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvttps2pi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvttps2pi<T, U>, 

CVTTPS2PI instruction

Instruction	Opcode	CPUID
CVTTPS2PI mm, xmm/m64	NP 0F 2C /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvttsd2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvttsd2si<T, U>, 

CVTTSD2SI instruction

Instruction	Opcode	CPUID
CVTTSD2SI r32, xmm1/m64	F2 0F 2C /r	SSE2
CVTTSD2SI r64, xmm1/m64	F2 o64 0F 2C /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cvttss2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmCvttss2si<T, U>, 

CVTTSS2SI instruction

Instruction	Opcode	CPUID
CVTTSS2SI r32, xmm1/m32	F3 0F 2C /r	SSE
CVTTSS2SI r64, xmm1/m32	F3 o64 0F 2C /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn cwd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCwd, 

CWD instruction

Instruction	Opcode	CPUID
CWD	o16 99	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn cwde(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmCwde, 

CWDE instruction

Instruction	Opcode	CPUID
CWDE	o32 98	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn daa(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmDaa, 

DAA instruction

Instruction	Opcode	CPUID
DAA	27	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn das(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmDas, 

DAS instruction

Instruction	Opcode	CPUID
DAS	2F	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn dec<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmDec<T>, 

DEC instruction

Instruction	Opcode	CPUID
DEC r16	o16 48+rw	8086+
DEC r32	o32 48+rd	386+
DEC r/m8	FE /1	8086+
DEC r/m16	o16 FF /1	8086+
DEC r/m32	o32 FF /1	386+
DEC r/m64	o64 FF /1	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn div<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmDiv<T>, 

DIV instruction

Instruction	Opcode	CPUID
DIV r/m8	F6 /6	8086+
DIV r/m16	o16 F7 /6	8086+
DIV r/m32	o32 F7 /6	386+
DIV r/m64	o64 F7 /6	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn divpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmDivpd<T, U>, 

DIVPD instruction

Instruction	Opcode	CPUID
DIVPD xmm1, xmm2/m128	66 0F 5E /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn divps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmDivps<T, U>, 

DIVPS instruction

Instruction	Opcode	CPUID
DIVPS xmm1, xmm2/m128	NP 0F 5E /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn divsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmDivsd<T, U>, 

DIVSD instruction

Instruction	Opcode	CPUID
DIVSD xmm1, xmm2/m64	F2 0F 5E /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn divss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmDivss<T, U>, 

DIVSS instruction

Instruction	Opcode	CPUID
DIVSS xmm1, xmm2/m32	F3 0F 5E /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn dmint(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmDmint, 

DMINT instruction

Instruction	Opcode	CPUID
DMINT	0F 39	AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

pub fn dppd<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmDppd<T, U, V>, 

DPPD instruction

Instruction	Opcode	CPUID
DPPD xmm1, xmm2/m128, imm8	66 0F 3A 41 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn dpps<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmDpps<T, U, V>, 

DPPS instruction

Instruction	Opcode	CPUID
DPPS xmm1, xmm2/m128, imm8	66 0F 3A 40 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn emms(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmEmms, 

EMMS instruction

Instruction	Opcode	CPUID
EMMS	NP 0F 77	MMX

Errors

Fails if an operand is invalid (basic checks only)

pub fn encls(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmEncls, 

ENCLS instruction

Instruction	Opcode	CPUID
ENCLS	NP 0F 01 CF	SGX1

Errors

Fails if an operand is invalid (basic checks only)

pub fn enclu(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmEnclu, 

ENCLU instruction

Instruction	Opcode	CPUID
ENCLU	NP 0F 01 D7	SGX1

Errors

Fails if an operand is invalid (basic checks only)

pub fn enclv(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmEnclv, 

ENCLV instruction

Instruction	Opcode	CPUID
ENCLV	NP 0F 01 C0	OSS

Errors

Fails if an operand is invalid (basic checks only)

pub fn encodekey128<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmEncodekey128<T, U>, 

ENCODEKEY128 instruction

Instruction	Opcode	CPUID
ENCODEKEY128 r32, r32, <XMM0-2>, <XMM4-6>	F3 0F 38 FA 11:rrr:bbb	AESKLE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn encodekey256<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmEncodekey256<T, U>, 

ENCODEKEY256 instruction

Instruction	Opcode	CPUID
ENCODEKEY256 r32, r32, <XMM0-6>	F3 0F 38 FB 11:rrr:bbb	AESKLE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn endbr32(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmEndbr32, 

ENDBR32 instruction

Instruction	Opcode	CPUID
ENDBR32	F3 0F 1E FB	CET_IBT

Errors

Fails if an operand is invalid (basic checks only)

pub fn endbr64(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmEndbr64, 

ENDBR64 instruction

Instruction	Opcode	CPUID
ENDBR64	F3 0F 1E FA	CET_IBT

Errors

Fails if an operand is invalid (basic checks only)

pub fn enqcmd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmEnqcmd<T, U>, 

ENQCMD instruction

Instruction	Opcode	CPUID
ENQCMD r16, m512	a16 F2 0F 38 F8 !(11):rrr:bbb	ENQCMD
ENQCMD r32, m512	a32 F2 0F 38 F8 !(11):rrr:bbb	ENQCMD
ENQCMD r64, m512	a64 F2 0F 38 F8 !(11):rrr:bbb	ENQCMD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn enqcmds<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmEnqcmds<T, U>, 

ENQCMDS instruction

Instruction	Opcode	CPUID
ENQCMDS r16, m512	a16 F3 0F 38 F8 !(11):rrr:bbb	ENQCMD
ENQCMDS r32, m512	a32 F3 0F 38 F8 !(11):rrr:bbb	ENQCMD
ENQCMDS r64, m512	a64 F3 0F 38 F8 !(11):rrr:bbb	ENQCMD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn enter<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmEnter<T, U>, 

ENTER instruction

Instruction	Opcode	CPUID
ENTER imm16, imm8	o16 C8 iw ib	186+
ENTER imm16, imm8	o32 C8 iw ib	386+
ENTER imm16, imm8	o64 C8 iw ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn erets(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmErets, 

ERETS instruction

Instruction	Opcode	CPUID
ERETS	F2 0F 01 CA	FRED

Errors

Fails if an operand is invalid (basic checks only)

pub fn eretu(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmEretu, 

ERETU instruction

Instruction	Opcode	CPUID
ERETU	F3 0F 01 CA	FRED

Errors

Fails if an operand is invalid (basic checks only)

pub fn extractps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmExtractps<T, U, V>, 

EXTRACTPS instruction

Instruction	Opcode	CPUID
EXTRACTPS r/m32, xmm1, imm8	66 0F 3A 17 /r ib	SSE4.1
EXTRACTPS r64/m32, xmm1, imm8	66 o64 0F 3A 17 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn extrq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmExtrq<T, U>, 

EXTRQ instruction

Instruction	Opcode	CPUID
EXTRQ xmm1, xmm2	66 0F 79 /r	SSE4A

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn extrq_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmExtrq3<T, U, V>, 

EXTRQ instruction

Instruction	Opcode	CPUID
EXTRQ xmm1, imm8, imm8	66 0F 78 /0 ib ib	SSE4A

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn f2xm1(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmF2xm1, 

F2XM1 instruction

Instruction	Opcode	CPUID
F2XM1	D9 F0	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fabs(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFabs, 

FABS instruction

Instruction	Opcode	CPUID
FABS	D9 E1	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fadd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFadd<T>, 

FADD instruction

Instruction	Opcode	CPUID
FADD m32fp	D8 /0	8087+
FADD m64fp	DC /0	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fadd_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFadd2<T, U>, 

FADD instruction

Instruction	Opcode	CPUID
FADD ST(0), ST(i)	D8 C0+i	8087+
FADD ST(i), ST(0)	DC C0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn faddp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFaddp<T, U>, 

FADDP instruction

Instruction	Opcode	CPUID
FADDP ST(i), ST(0)	DE C0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fbld<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFbld<T>, 

FBLD instruction

Instruction	Opcode	CPUID
FBLD m80bcd	DF /4	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fbstp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFbstp<T>, 

FBSTP instruction

Instruction	Opcode	CPUID
FBSTP m80bcd	DF /6	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fchs(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFchs, 

FCHS instruction

Instruction	Opcode	CPUID
FCHS	D9 E0	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fclex(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFclex, 

FCLEX instruction

Instruction	Opcode	CPUID
FCLEX	9B DB E2	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fcmovb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcmovb<T, U>, 

FCMOVB instruction

Instruction	Opcode	CPUID
FCMOVB ST(0), ST(i)	DA C0+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcmovbe<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcmovbe<T, U>, 

FCMOVBE instruction

Instruction	Opcode	CPUID
FCMOVBE ST(0), ST(i)	DA D0+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcmove<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcmove<T, U>, 

FCMOVE instruction

Instruction	Opcode	CPUID
FCMOVE ST(0), ST(i)	DA C8+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcmovnb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcmovnb<T, U>, 

FCMOVNB instruction

Instruction	Opcode	CPUID
FCMOVNB ST(0), ST(i)	DB C0+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcmovnbe<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcmovnbe<T, U>, 

FCMOVNBE instruction

Instruction	Opcode	CPUID
FCMOVNBE ST(0), ST(i)	DB D0+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcmovne<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcmovne<T, U>, 

FCMOVNE instruction

Instruction	Opcode	CPUID
FCMOVNE ST(0), ST(i)	DB C8+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcmovnu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcmovnu<T, U>, 

FCMOVNU instruction

Instruction	Opcode	CPUID
FCMOVNU ST(0), ST(i)	DB D8+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcmovu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcmovu<T, U>, 

FCMOVU instruction

Instruction	Opcode	CPUID
FCMOVU ST(0), ST(i)	DA D8+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcom<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFcom<T>, 

FCOM instruction

Instruction	Opcode	CPUID
FCOM m32fp	D8 /2	8087+
FCOM m64fp	DC /2	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fcom_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcom2<T, U>, 

FCOM instruction

Instruction	Opcode	CPUID
FCOM ST(i)	D8 D0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcomi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcomi<T, U>, 

FCOMI instruction

Instruction	Opcode	CPUID
FCOMI ST, ST(i)	DB F0+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcomip<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcomip<T, U>, 

FCOMIP instruction

Instruction	Opcode	CPUID
FCOMIP ST, ST(i)	DF F0+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcomp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFcomp<T>, 

FCOMP instruction

Instruction	Opcode	CPUID
FCOMP m32fp	D8 /3	8087+
FCOMP m64fp	DC /3	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fcomp_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFcomp2<T, U>, 

FCOMP instruction

Instruction	Opcode	CPUID
FCOMP ST(i)	D8 D8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fcompp(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFcompp, 

FCOMPP instruction

Instruction	Opcode	CPUID
FCOMPP	DE D9	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fcos(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFcos, 

FCOS instruction

Instruction	Opcode	CPUID
FCOS	D9 FF	387+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fdecstp(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFdecstp, 

FDECSTP instruction

Instruction	Opcode	CPUID
FDECSTP	D9 F6	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fdisi(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFdisi, 

FDISI instruction

Instruction	Opcode	CPUID
FDISI	9B DB E1	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fdiv<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFdiv<T>, 

FDIV instruction

Instruction	Opcode	CPUID
FDIV m32fp	D8 /6	8087+
FDIV m64fp	DC /6	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fdiv_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFdiv2<T, U>, 

FDIV instruction

Instruction	Opcode	CPUID
FDIV ST(0), ST(i)	D8 F0+i	8087+
FDIV ST(i), ST(0)	DC F8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fdivp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFdivp<T, U>, 

FDIVP instruction

Instruction	Opcode	CPUID
FDIVP ST(i), ST(0)	DE F8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fdivr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFdivr<T>, 

FDIVR instruction

Instruction	Opcode	CPUID
FDIVR m32fp	D8 /7	8087+
FDIVR m64fp	DC /7	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fdivr_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFdivr2<T, U>, 

FDIVR instruction

Instruction	Opcode	CPUID
FDIVR ST(0), ST(i)	D8 F8+i	8087+
FDIVR ST(i), ST(0)	DC F0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fdivrp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFdivrp<T, U>, 

FDIVRP instruction

Instruction	Opcode	CPUID
FDIVRP ST(i), ST(0)	DE F0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn femms(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFemms, 

FEMMS instruction

Instruction	Opcode	CPUID
FEMMS	0F 0E	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

pub fn feni(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFeni, 

FENI instruction

Instruction	Opcode	CPUID
FENI	9B DB E0	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn ffree<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFfree<T>, 

FFREE instruction

Instruction	Opcode	CPUID
FFREE ST(i)	DD C0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn ffreep<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFfreep<T>, 

FFREEP instruction

Instruction	Opcode	CPUID
FFREEP ST(i)	DF C0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fiadd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFiadd<T>, 

FIADD instruction

Instruction	Opcode	CPUID
FIADD m32int	DA /0	8087+
FIADD m16int	DE /0	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn ficom<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFicom<T>, 

FICOM instruction

Instruction	Opcode	CPUID
FICOM m32int	DA /2	8087+
FICOM m16int	DE /2	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn ficomp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFicomp<T>, 

FICOMP instruction

Instruction	Opcode	CPUID
FICOMP m32int	DA /3	8087+
FICOMP m16int	DE /3	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fidiv<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFidiv<T>, 

FIDIV instruction

Instruction	Opcode	CPUID
FIDIV m32int	DA /6	8087+
FIDIV m16int	DE /6	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fidivr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFidivr<T>, 

FIDIVR instruction

Instruction	Opcode	CPUID
FIDIVR m32int	DA /7	8087+
FIDIVR m16int	DE /7	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fild<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFild<T>, 

FILD instruction

Instruction	Opcode	CPUID
FILD m32int	DB /0	8087+
FILD m16int	DF /0	8087+
FILD m64int	DF /5	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fimul<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFimul<T>, 

FIMUL instruction

Instruction	Opcode	CPUID
FIMUL m32int	DA /1	8087+
FIMUL m16int	DE /1	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fincstp(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFincstp, 

FINCSTP instruction

Instruction	Opcode	CPUID
FINCSTP	D9 F7	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn finit(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFinit, 

FINIT instruction

Instruction	Opcode	CPUID
FINIT	9B DB E3	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fist<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFist<T>, 

FIST instruction

Instruction	Opcode	CPUID
FIST m32int	DB /2	8087+
FIST m16int	DF /2	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fistp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFistp<T>, 

FISTP instruction

Instruction	Opcode	CPUID
FISTP m32int	DB /3	8087+
FISTP m16int	DF /3	8087+
FISTP m64int	DF /7	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fisttp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFisttp<T>, 

FISTTP instruction

Instruction	Opcode	CPUID
FISTTP m32int	DB /1	8087+ SSE3
FISTTP m64int	DD /1	8087+ SSE3
FISTTP m16int	DF /1	8087+ SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fisub<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFisub<T>, 

FISUB instruction

Instruction	Opcode	CPUID
FISUB m32int	DA /4	8087+
FISUB m16int	DE /4	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fisubr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFisubr<T>, 

FISUBR instruction

Instruction	Opcode	CPUID
FISUBR m32int	DA /5	8087+
FISUBR m16int	DE /5	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fld<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFld<T>, 

FLD instruction

Instruction	Opcode	CPUID
FLD m32fp	D9 /0	8087+
FLD m80fp	DB /5	8087+
FLD m64fp	DD /0	8087+
FLD ST(i)	D9 C0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fld1(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFld1, 

FLD1 instruction

Instruction	Opcode	CPUID
FLD1	D9 E8	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fldcw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFldcw<T>, 

FLDCW instruction

Instruction	Opcode	CPUID
FLDCW m2byte	D9 /5	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fldenv<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFldenv<T>, 

FLDENV instruction

Instruction	Opcode	CPUID
FLDENV m14byte	o16 D9 /4	8087+
FLDENV m28byte	o32 D9 /4	387+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fldl2e(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFldl2e, 

FLDL2E instruction

Instruction	Opcode	CPUID
FLDL2E	D9 EA	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fldl2t(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFldl2t, 

FLDL2T instruction

Instruction	Opcode	CPUID
FLDL2T	D9 E9	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fldlg2(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFldlg2, 

FLDLG2 instruction

Instruction	Opcode	CPUID
FLDLG2	D9 EC	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fldln2(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFldln2, 

FLDLN2 instruction

Instruction	Opcode	CPUID
FLDLN2	D9 ED	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fldpi(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFldpi, 

FLDPI instruction

Instruction	Opcode	CPUID
FLDPI	D9 EB	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fldz(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFldz, 

FLDZ instruction

Instruction	Opcode	CPUID
FLDZ	D9 EE	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fmul<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFmul<T>, 

FMUL instruction

Instruction	Opcode	CPUID
FMUL m32fp	D8 /1	8087+
FMUL m64fp	DC /1	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fmul_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFmul2<T, U>, 

FMUL instruction

Instruction	Opcode	CPUID
FMUL ST(0), ST(i)	D8 C8+i	8087+
FMUL ST(i), ST(0)	DC C8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fmulp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFmulp<T, U>, 

FMULP instruction

Instruction	Opcode	CPUID
FMULP ST(i), ST(0)	DE C8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fnclex(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFnclex, 

FNCLEX instruction

Instruction	Opcode	CPUID
FNCLEX	DB E2	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fndisi(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFndisi, 

FNDISI instruction

Instruction	Opcode	CPUID
FNDISI	DB E1	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fneni(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFneni, 

FNENI instruction

Instruction	Opcode	CPUID
FNENI	DB E0	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fninit(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFninit, 

FNINIT instruction

Instruction	Opcode	CPUID
FNINIT	DB E3	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fnop(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFnop, 

FNOP instruction

Instruction	Opcode	CPUID
FNOP	D9 D0	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fnsave<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFnsave<T>, 

FNSAVE instruction

Instruction	Opcode	CPUID
FNSAVE m94byte	o16 DD /6	8087+
FNSAVE m108byte	o32 DD /6	387+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fnsetpm(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFnsetpm, 

FNSETPM instruction

Instruction	Opcode	CPUID
FNSETPM	DB E4	287+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fnstcw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFnstcw<T>, 

FNSTCW instruction

Instruction	Opcode	CPUID
FNSTCW m2byte	D9 /7	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fnstdw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFnstdw<T>, 

FNSTDW instruction

Instruction	Opcode	CPUID
FNSTDW AX	DF E1	387 SL

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fnstenv<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFnstenv<T>, 

FNSTENV instruction

Instruction	Opcode	CPUID
FNSTENV m14byte	o16 D9 /6	8087+
FNSTENV m28byte	o32 D9 /6	387+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fnstsg<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFnstsg<T>, 

FNSTSG instruction

Instruction	Opcode	CPUID
FNSTSG AX	DF E2	387 SL

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fnstsw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFnstsw<T>, 

FNSTSW instruction

Instruction	Opcode	CPUID
FNSTSW m2byte	DD /7	8087+
FNSTSW AX	DF E0	287+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fpatan(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFpatan, 

FPATAN instruction

Instruction	Opcode	CPUID
FPATAN	D9 F3	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fprem(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFprem, 

FPREM instruction

Instruction	Opcode	CPUID
FPREM	D9 F8	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fprem1(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFprem1, 

FPREM1 instruction

Instruction	Opcode	CPUID
FPREM1	D9 F5	387+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fptan(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFptan, 

FPTAN instruction

Instruction	Opcode	CPUID
FPTAN	D9 F2	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn frndint(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFrndint, 

FRNDINT instruction

Instruction	Opcode	CPUID
FRNDINT	D9 FC	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn frstor<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFrstor<T>, 

FRSTOR instruction

Instruction	Opcode	CPUID
FRSTOR m94byte	o16 DD /4	8087+
FRSTOR m108byte	o32 DD /4	387+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn frstpm(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFrstpm, 

FRSTPM instruction

Instruction	Opcode	CPUID
FRSTPM	DB E5	287 XL

Errors

Fails if an operand is invalid (basic checks only)

pub fn fsave<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFsave<T>, 

FSAVE instruction

Instruction	Opcode	CPUID
FSAVE m94byte	9B o16 DD /6	8087+
FSAVE m108byte	9B o32 DD /6	387+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fscale(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFscale, 

FSCALE instruction

Instruction	Opcode	CPUID
FSCALE	D9 FD	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fsetpm(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFsetpm, 

FSETPM instruction

Instruction	Opcode	CPUID
FSETPM	9B DB E4	287+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fsin(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFsin, 

FSIN instruction

Instruction	Opcode	CPUID
FSIN	D9 FE	387+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fsincos(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFsincos, 

FSINCOS instruction

Instruction	Opcode	CPUID
FSINCOS	D9 FB	387+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fsqrt(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFsqrt, 

FSQRT instruction

Instruction	Opcode	CPUID
FSQRT	D9 FA	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fst<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFst<T>, 

FST instruction

Instruction	Opcode	CPUID
FST m32fp	D9 /2	8087+
FST m64fp	DD /2	8087+
FST ST(i)	DD D0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fstcw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFstcw<T>, 

FSTCW instruction

Instruction	Opcode	CPUID
FSTCW m2byte	9B D9 /7	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fstdw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFstdw<T>, 

FSTDW instruction

Instruction	Opcode	CPUID
FSTDW AX	9B DF E1	387 SL

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fstenv<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFstenv<T>, 

FSTENV instruction

Instruction	Opcode	CPUID
FSTENV m14byte	9B o16 D9 /6	8087+
FSTENV m28byte	9B o32 D9 /6	387+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fstp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFstp<T>, 

FSTP instruction

Instruction	Opcode	CPUID
FSTP m32fp	D9 /3	8087+
FSTP m80fp	DB /7	8087+
FSTP m64fp	DD /3	8087+
FSTP ST(i)	DD D8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fstpnce<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFstpnce<T>, 

FSTPNCE instruction

Instruction	Opcode	CPUID
FSTPNCE ST(i)	D9 D8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fstsg<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFstsg<T>, 

FSTSG instruction

Instruction	Opcode	CPUID
FSTSG AX	9B DF E2	387 SL

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fstsw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFstsw<T>, 

FSTSW instruction

Instruction	Opcode	CPUID
FSTSW m2byte	9B DD /7	8087+
FSTSW AX	9B DF E0	287+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fsub<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFsub<T>, 

FSUB instruction

Instruction	Opcode	CPUID
FSUB m32fp	D8 /4	8087+
FSUB m64fp	DC /4	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fsub_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFsub2<T, U>, 

FSUB instruction

Instruction	Opcode	CPUID
FSUB ST(0), ST(i)	D8 E0+i	8087+
FSUB ST(i), ST(0)	DC E8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fsubp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFsubp<T, U>, 

FSUBP instruction

Instruction	Opcode	CPUID
FSUBP ST(i), ST(0)	DE E8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fsubr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFsubr<T>, 

FSUBR instruction

Instruction	Opcode	CPUID
FSUBR m32fp	D8 /5	8087+
FSUBR m64fp	DC /5	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fsubr_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFsubr2<T, U>, 

FSUBR instruction

Instruction	Opcode	CPUID
FSUBR ST(0), ST(i)	D8 E8+i	8087+
FSUBR ST(i), ST(0)	DC E0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fsubrp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFsubrp<T, U>, 

FSUBRP instruction

Instruction	Opcode	CPUID
FSUBRP ST(i), ST(0)	DE E0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ftst(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFtst, 

FTST instruction

Instruction	Opcode	CPUID
FTST	D9 E4	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fucom<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFucom<T, U>, 

FUCOM instruction

Instruction	Opcode	CPUID
FUCOM ST(i)	DD E0+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fucomi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFucomi<T, U>, 

FUCOMI instruction

Instruction	Opcode	CPUID
FUCOMI ST, ST(i)	DB E8+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fucomip<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFucomip<T, U>, 

FUCOMIP instruction

Instruction	Opcode	CPUID
FUCOMIP ST, ST(i)	DF E8+i	8087+ CMOV

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fucomp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFucomp<T, U>, 

FUCOMP instruction

Instruction	Opcode	CPUID
FUCOMP ST(i)	DD E8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fucompp(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFucompp, 

FUCOMPP instruction

Instruction	Opcode	CPUID
FUCOMPP	DA E9	387+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fxam(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFxam, 

FXAM instruction

Instruction	Opcode	CPUID
FXAM	D9 E5	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fxch<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmFxch<T, U>, 

FXCH instruction

Instruction	Opcode	CPUID
FXCH ST(i)	D9 C8+i	8087+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn fxrstor<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFxrstor<T>, 

FXRSTOR instruction

Instruction	Opcode	CPUID
FXRSTOR m512byte	NP 0F AE /1	FXSR

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fxrstor64<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFxrstor64<T>, 

FXRSTOR64 instruction

Instruction	Opcode	CPUID
FXRSTOR64 m512byte	NP o64 0F AE /1	FXSR

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fxsave<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFxsave<T>, 

FXSAVE instruction

Instruction	Opcode	CPUID
FXSAVE m512byte	NP 0F AE /0	FXSR

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fxsave64<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmFxsave64<T>, 

FXSAVE64 instruction

Instruction	Opcode	CPUID
FXSAVE64 m512byte	NP o64 0F AE /0	FXSR

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn fxtract(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFxtract, 

FXTRACT instruction

Instruction	Opcode	CPUID
FXTRACT	D9 F4	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fyl2x(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFyl2x, 

FYL2X instruction

Instruction	Opcode	CPUID
FYL2X	D9 F1	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn fyl2xp1(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmFyl2xp1, 

FYL2XP1 instruction

Instruction	Opcode	CPUID
FYL2XP1	D9 F9	8087+

Errors

Fails if an operand is invalid (basic checks only)

pub fn getsec(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmGetsec, 

GETSEC instruction

Instruction	Opcode	CPUID
GETSEC	NP 0F 37	SMX

Errors

Fails if an operand is invalid (basic checks only)

pub fn getsecq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmGetsecq, 

GETSECQ instruction

Instruction	Opcode	CPUID
GETSECQ	NP o64 0F 37	SMX

Errors

Fails if an operand is invalid (basic checks only)

pub fn gf2p8affineinvqb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmGf2p8affineinvqb<T, U, V>, 

GF2P8AFFINEINVQB instruction

Instruction	Opcode	CPUID
GF2P8AFFINEINVQB xmm1, xmm2/m128, imm8	66 0F 3A CF /r ib	GFNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn gf2p8affineqb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmGf2p8affineqb<T, U, V>, 

GF2P8AFFINEQB instruction

Instruction	Opcode	CPUID
GF2P8AFFINEQB xmm1, xmm2/m128, imm8	66 0F 3A CE /r ib	GFNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn gf2p8mulb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmGf2p8mulb<T, U>, 

GF2P8MULB instruction

Instruction	Opcode	CPUID
GF2P8MULB xmm1, xmm2/m128	66 0F 38 CF /r	GFNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn haddpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmHaddpd<T, U>, 

HADDPD instruction

Instruction	Opcode	CPUID
HADDPD xmm1, xmm2/m128	66 0F 7C /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn haddps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmHaddps<T, U>, 

HADDPS instruction

Instruction	Opcode	CPUID
HADDPS xmm1, xmm2/m128	F2 0F 7C /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn hlt(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmHlt, 

HLT instruction

Instruction	Opcode	CPUID
HLT	F4	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn hreset<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmHreset<T>, 

HRESET instruction

Instruction	Opcode	CPUID
HRESET imm8, <EAX>	F3 0F 3A F0 C0 ib	HRESET

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn hsubpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmHsubpd<T, U>, 

HSUBPD instruction

Instruction	Opcode	CPUID
HSUBPD xmm1, xmm2/m128	66 0F 7D /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn hsubps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmHsubps<T, U>, 

HSUBPS instruction

Instruction	Opcode	CPUID
HSUBPS xmm1, xmm2/m128	F2 0F 7D /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ibts<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmIbts<T, U>, 

IBTS instruction

Instruction	Opcode	CPUID
IBTS r/m16, r16	o16 0F A7 /r	386 A0
IBTS r/m32, r32	o32 0F A7 /r	386 A0

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn idiv<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmIdiv<T>, 

IDIV instruction

Instruction	Opcode	CPUID
IDIV r/m8	F6 /7	8086+
IDIV r/m16	o16 F7 /7	8086+
IDIV r/m32	o32 F7 /7	386+
IDIV r/m64	o64 F7 /7	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn imul<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmImul<T>, 

IMUL instruction

Instruction	Opcode	CPUID
IMUL r/m8	F6 /5	8086+
IMUL r/m16	o16 F7 /5	8086+
IMUL r/m32	o32 F7 /5	386+
IMUL r/m64	o64 F7 /5	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn imul_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmImul2<T, U>, 

IMUL instruction

Instruction	Opcode	CPUID
IMUL r16, r/m16	o16 0F AF /r	386+
IMUL r32, r/m32	o32 0F AF /r	386+
IMUL r64, r/m64	o64 0F AF /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn imul_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmImul3<T, U, V>, 

IMUL instruction

Instruction	Opcode	CPUID
IMUL r16, r/m16, imm16	o16 69 /r iw	186+
IMUL r32, r/m32, imm32	o32 69 /r id	386+
IMUL r64, r/m64, imm32	o64 69 /r id	X64
IMUL r16, r/m16, imm8	o16 6B /r ib	186+
IMUL r32, r/m32, imm8	o32 6B /r ib	386+
IMUL r64, r/m64, imm8	o64 6B /r ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn in_<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmIn<T, U>, 

IN instruction

Instruction	Opcode	CPUID
IN AL, imm8	E4 ib	8086+
IN AX, imm8	o16 E5 ib	8086+
IN EAX, imm8	o32 E5 ib	386+
IN AL, DX	EC	8086+
IN AX, DX	o16 ED	8086+
IN EAX, DX	o32 ED	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn inc<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmInc<T>, 

INC instruction

Instruction	Opcode	CPUID
INC r16	o16 40+rw	8086+
INC r32	o32 40+rd	386+
INC r/m8	FE /0	8086+
INC r/m16	o16 FF /0	8086+
INC r/m32	o32 FF /0	386+
INC r/m64	o64 FF /0	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn incsspd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmIncsspd<T>, 

INCSSPD instruction

Instruction	Opcode	CPUID
INCSSPD r32	F3 0F AE /5	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn incsspq<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmIncsspq<T>, 

INCSSPQ instruction

Instruction	Opcode	CPUID
INCSSPQ r64	F3 o64 0F AE /5	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn insb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmInsb, 

INSB instruction

Instruction	Opcode	CPUID
INSB	6C	186+

Errors

Fails if an operand is invalid (basic checks only)

pub fn insd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmInsd, 

INSD instruction

Instruction	Opcode	CPUID
INSD	o32 6D	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn insertps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmInsertps<T, U, V>, 

INSERTPS instruction

Instruction	Opcode	CPUID
INSERTPS xmm1, xmm2/m32, imm8	66 0F 3A 21 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn insertq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmInsertq<T, U>, 

INSERTQ instruction

Instruction	Opcode	CPUID
INSERTQ xmm1, xmm2	F2 0F 79 /r	SSE4A

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn insertq_4<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmInsertq4<T, U, V, W>, 

INSERTQ instruction

Instruction	Opcode	CPUID
INSERTQ xmm1, xmm2, imm8, imm8	F2 0F 78 /r ib ib	SSE4A

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn insw(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmInsw, 

INSW instruction

Instruction	Opcode	CPUID
INSW	o16 6D	186+

Errors

Fails if an operand is invalid (basic checks only)

pub fn int<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmInt<T>, 

INT instruction

Instruction	Opcode	CPUID
INT imm8	CD ib	8086+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn int1(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmInt1, 

INT1 instruction

Instruction	Opcode	CPUID
INT1	F1	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn int3(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmInt3, 

INT3 instruction

Instruction	Opcode	CPUID
INT3	CC	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn into(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmInto, 

INTO instruction

Instruction	Opcode	CPUID
INTO	CE	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn invd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmInvd, 

INVD instruction

Instruction	Opcode	CPUID
INVD	0F 08	486+

Errors

Fails if an operand is invalid (basic checks only)

pub fn invept<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmInvept<T, U>, 

INVEPT instruction

Instruction	Opcode	CPUID
INVEPT r32, m128	66 0F 38 80 /r	VMX IA32_VMX_EPT_VPID_CAP[bit 20]
INVEPT r64, m128	66 0F 38 80 /r	VMX IA32_VMX_EPT_VPID_CAP[bit 20]

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn invlpg<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmInvlpg<T>, 

INVLPG instruction

Instruction	Opcode	CPUID
INVLPG m	0F 01 /7	486+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn invlpga(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmInvlpga, 

INVLPGA instruction

Instruction	Opcode	CPUID
INVLPGA	a16 0F 01 DF	SVM
INVLPGA	a32 0F 01 DF	SVM
INVLPGA	a64 0F 01 DF	SVM

Errors

Fails if an operand is invalid (basic checks only)

pub fn invlpgb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmInvlpgb, 

INVLPGB instruction

Instruction	Opcode	CPUID
INVLPGB	a16 NP 0F 01 FE	INVLPGB
INVLPGB	a32 NP 0F 01 FE	INVLPGB
INVLPGB	a64 NP 0F 01 FE	INVLPGB

Errors

Fails if an operand is invalid (basic checks only)

pub fn invpcid<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmInvpcid<T, U>, 

INVPCID instruction

Instruction	Opcode	CPUID
INVPCID r32, m128	66 0F 38 82 /r	INVPCID
INVPCID r64, m128	66 0F 38 82 /r	INVPCID

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn invvpid<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmInvvpid<T, U>, 

INVVPID instruction

Instruction	Opcode	CPUID
INVVPID r32, m128	66 0F 38 81 /r	VMX IA32_VMX_EPT_VPID_CAP[bit 32]
INVVPID r64, m128	66 0F 38 81 /r	VMX IA32_VMX_EPT_VPID_CAP[bit 32]

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn iret(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmIret, 

IRET instruction

Instruction	Opcode	CPUID
IRET	o16 CF	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn iretd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmIretd, 

IRETD instruction

Instruction	Opcode	CPUID
IRETD	o32 CF	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn iretq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmIretq, 

IRETQ instruction

Instruction	Opcode	CPUID
IRETQ	o64 CF	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn ja<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJa<T>, 

JA instruction

Instruction	Opcode	CPUID
JA rel8	o16 77 cb	8086+
JA rel8	o32 77 cb	386+
JA rel8	o64 77 cb	X64
JA rel16	o16 0F 87 cw	386+
JA rel32	o32 0F 87 cd	386+
JA rel32	o64 0F 87 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jae<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJae<T>, 

JAE instruction

Instruction	Opcode	CPUID
JAE rel8	o16 73 cb	8086+
JAE rel8	o32 73 cb	386+
JAE rel8	o64 73 cb	X64
JAE rel16	o16 0F 83 cw	386+
JAE rel32	o32 0F 83 cd	386+
JAE rel32	o64 0F 83 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jb<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJb<T>, 

JB instruction

Instruction	Opcode	CPUID
JB rel8	o16 72 cb	8086+
JB rel8	o32 72 cb	386+
JB rel8	o64 72 cb	X64
JB rel16	o16 0F 82 cw	386+
JB rel32	o32 0F 82 cd	386+
JB rel32	o64 0F 82 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jbe<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJbe<T>, 

JBE instruction

Instruction	Opcode	CPUID
JBE rel8	o16 76 cb	8086+
JBE rel8	o32 76 cb	386+
JBE rel8	o64 76 cb	X64
JBE rel16	o16 0F 86 cw	386+
JBE rel32	o32 0F 86 cd	386+
JBE rel32	o64 0F 86 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jc<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJc<T>, 

JC instruction

Instruction	Opcode	CPUID
JB rel8	o16 72 cb	8086+
JB rel8	o32 72 cb	386+
JB rel8	o64 72 cb	X64
JB rel16	o16 0F 82 cw	386+
JB rel32	o32 0F 82 cd	386+
JB rel32	o64 0F 82 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jcxz<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJcxz<T>, 

JCXZ instruction

Instruction	Opcode	CPUID
JCXZ rel8	a16 o16 E3 cb	8086+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn je<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJe<T>, 

JE instruction

Instruction	Opcode	CPUID
JE rel8	o16 74 cb	8086+
JE rel8	o32 74 cb	386+
JE rel8	o64 74 cb	X64
JE rel16	o16 0F 84 cw	386+
JE rel32	o32 0F 84 cd	386+
JE rel32	o64 0F 84 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jecxz<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJecxz<T>, 

JECXZ instruction

Instruction	Opcode	CPUID
JECXZ rel8	a32 o32 E3 cb	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jg<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJg<T>, 

JG instruction

Instruction	Opcode	CPUID
JG rel8	o16 7F cb	8086+
JG rel8	o32 7F cb	386+
JG rel8	o64 7F cb	X64
JG rel16	o16 0F 8F cw	386+
JG rel32	o32 0F 8F cd	386+
JG rel32	o64 0F 8F cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jge<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJge<T>, 

JGE instruction

Instruction	Opcode	CPUID
JGE rel8	o16 7D cb	8086+
JGE rel8	o32 7D cb	386+
JGE rel8	o64 7D cb	X64
JGE rel16	o16 0F 8D cw	386+
JGE rel32	o32 0F 8D cd	386+
JGE rel32	o64 0F 8D cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jl<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJl<T>, 

JL instruction

Instruction	Opcode	CPUID
JL rel8	o16 7C cb	8086+
JL rel8	o32 7C cb	386+
JL rel8	o64 7C cb	X64
JL rel16	o16 0F 8C cw	386+
JL rel32	o32 0F 8C cd	386+
JL rel32	o64 0F 8C cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jle<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJle<T>, 

JLE instruction

Instruction	Opcode	CPUID
JLE rel8	o16 7E cb	8086+
JLE rel8	o32 7E cb	386+
JLE rel8	o64 7E cb	X64
JLE rel16	o16 0F 8E cw	386+
JLE rel32	o32 0F 8E cd	386+
JLE rel32	o64 0F 8E cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jmp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJmp<T>, 

JMP instruction

Instruction	Opcode	CPUID
JMP rel16	o16 E9 cw	8086+
JMP rel32	o32 E9 cd	386+
JMP rel32	o64 E9 cd	X64
JMP rel8	o16 EB cb	8086+
JMP rel8	o32 EB cb	386+
JMP rel8	o64 EB cb	X64
JMP r/m16	o16 FF /4	8086+
JMP r/m32	o32 FF /4	386+
JMP r/m64	o64 FF /4	X64
JMP m16:16	o16 FF /5	8086+
JMP m16:32	o32 FF /5	386+
JMP m16:64	o64 FF /5	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jmpe<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJmpe<T>, 

JMPE instruction

Instruction	Opcode	CPUID
JMPE r/m16	o16 0F 00 /6	IA-64
JMPE r/m32	o32 0F 00 /6	IA-64
JMPE disp16	o16 0F B8 cw	IA-64
JMPE disp32	o32 0F B8 cd	IA-64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jna<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJna<T>, 

JNA instruction

Instruction	Opcode	CPUID
JBE rel8	o16 76 cb	8086+
JBE rel8	o32 76 cb	386+
JBE rel8	o64 76 cb	X64
JBE rel16	o16 0F 86 cw	386+
JBE rel32	o32 0F 86 cd	386+
JBE rel32	o64 0F 86 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jnae<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJnae<T>, 

JNAE instruction

Instruction	Opcode	CPUID
JB rel8	o16 72 cb	8086+
JB rel8	o32 72 cb	386+
JB rel8	o64 72 cb	X64
JB rel16	o16 0F 82 cw	386+
JB rel32	o32 0F 82 cd	386+
JB rel32	o64 0F 82 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jnb<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJnb<T>, 

JNB instruction

Instruction	Opcode	CPUID
JAE rel8	o16 73 cb	8086+
JAE rel8	o32 73 cb	386+
JAE rel8	o64 73 cb	X64
JAE rel16	o16 0F 83 cw	386+
JAE rel32	o32 0F 83 cd	386+
JAE rel32	o64 0F 83 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jnbe<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJnbe<T>, 

JNBE instruction

Instruction	Opcode	CPUID
JA rel8	o16 77 cb	8086+
JA rel8	o32 77 cb	386+
JA rel8	o64 77 cb	X64
JA rel16	o16 0F 87 cw	386+
JA rel32	o32 0F 87 cd	386+
JA rel32	o64 0F 87 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jnc<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJnc<T>, 

JNC instruction

Instruction	Opcode	CPUID
JAE rel8	o16 73 cb	8086+
JAE rel8	o32 73 cb	386+
JAE rel8	o64 73 cb	X64
JAE rel16	o16 0F 83 cw	386+
JAE rel32	o32 0F 83 cd	386+
JAE rel32	o64 0F 83 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jne<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJne<T>, 

JNE instruction

Instruction	Opcode	CPUID
JNE rel8	o16 75 cb	8086+
JNE rel8	o32 75 cb	386+
JNE rel8	o64 75 cb	X64
JNE rel16	o16 0F 85 cw	386+
JNE rel32	o32 0F 85 cd	386+
JNE rel32	o64 0F 85 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jng<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJng<T>, 

JNG instruction

Instruction	Opcode	CPUID
JLE rel8	o16 7E cb	8086+
JLE rel8	o32 7E cb	386+
JLE rel8	o64 7E cb	X64
JLE rel16	o16 0F 8E cw	386+
JLE rel32	o32 0F 8E cd	386+
JLE rel32	o64 0F 8E cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jnge<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJnge<T>, 

JNGE instruction

Instruction	Opcode	CPUID
JL rel8	o16 7C cb	8086+
JL rel8	o32 7C cb	386+
JL rel8	o64 7C cb	X64
JL rel16	o16 0F 8C cw	386+
JL rel32	o32 0F 8C cd	386+
JL rel32	o64 0F 8C cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jnl<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJnl<T>, 

JNL instruction

Instruction	Opcode	CPUID
JGE rel8	o16 7D cb	8086+
JGE rel8	o32 7D cb	386+
JGE rel8	o64 7D cb	X64
JGE rel16	o16 0F 8D cw	386+
JGE rel32	o32 0F 8D cd	386+
JGE rel32	o64 0F 8D cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jnle<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJnle<T>, 

JNLE instruction

Instruction	Opcode	CPUID
JG rel8	o16 7F cb	8086+
JG rel8	o32 7F cb	386+
JG rel8	o64 7F cb	X64
JG rel16	o16 0F 8F cw	386+
JG rel32	o32 0F 8F cd	386+
JG rel32	o64 0F 8F cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jno<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJno<T>, 

JNO instruction

Instruction	Opcode	CPUID
JNO rel8	o16 71 cb	8086+
JNO rel8	o32 71 cb	386+
JNO rel8	o64 71 cb	X64
JNO rel16	o16 0F 81 cw	386+
JNO rel32	o32 0F 81 cd	386+
JNO rel32	o64 0F 81 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jnp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJnp<T>, 

JNP instruction

Instruction	Opcode	CPUID
JNP rel8	o16 7B cb	8086+
JNP rel8	o32 7B cb	386+
JNP rel8	o64 7B cb	X64
JNP rel16	o16 0F 8B cw	386+
JNP rel32	o32 0F 8B cd	386+
JNP rel32	o64 0F 8B cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jns<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJns<T>, 

JNS instruction

Instruction	Opcode	CPUID
JNS rel8	o16 79 cb	8086+
JNS rel8	o32 79 cb	386+
JNS rel8	o64 79 cb	X64
JNS rel16	o16 0F 89 cw	386+
JNS rel32	o32 0F 89 cd	386+
JNS rel32	o64 0F 89 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jnz<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJnz<T>, 

JNZ instruction

Instruction	Opcode	CPUID
JNE rel8	o16 75 cb	8086+
JNE rel8	o32 75 cb	386+
JNE rel8	o64 75 cb	X64
JNE rel16	o16 0F 85 cw	386+
JNE rel32	o32 0F 85 cd	386+
JNE rel32	o64 0F 85 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jo<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJo<T>, 

JO instruction

Instruction	Opcode	CPUID
JO rel8	o16 70 cb	8086+
JO rel8	o32 70 cb	386+
JO rel8	o64 70 cb	X64
JO rel16	o16 0F 80 cw	386+
JO rel32	o32 0F 80 cd	386+
JO rel32	o64 0F 80 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJp<T>, 

JP instruction

Instruction	Opcode	CPUID
JP rel8	o16 7A cb	8086+
JP rel8	o32 7A cb	386+
JP rel8	o64 7A cb	X64
JP rel16	o16 0F 8A cw	386+
JP rel32	o32 0F 8A cd	386+
JP rel32	o64 0F 8A cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jpe<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJpe<T>, 

JPE instruction

Instruction	Opcode	CPUID
JP rel8	o16 7A cb	8086+
JP rel8	o32 7A cb	386+
JP rel8	o64 7A cb	X64
JP rel16	o16 0F 8A cw	386+
JP rel32	o32 0F 8A cd	386+
JP rel32	o64 0F 8A cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jpo<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJpo<T>, 

JPO instruction

Instruction	Opcode	CPUID
JNP rel8	o16 7B cb	8086+
JNP rel8	o32 7B cb	386+
JNP rel8	o64 7B cb	X64
JNP rel16	o16 0F 8B cw	386+
JNP rel32	o32 0F 8B cd	386+
JNP rel32	o64 0F 8B cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jrcxz<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJrcxz<T>, 

JRCXZ instruction

Instruction	Opcode	CPUID
JRCXZ rel8	a64 o64 E3 cb	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn js<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJs<T>, 

JS instruction

Instruction	Opcode	CPUID
JS rel8	o16 78 cb	8086+
JS rel8	o32 78 cb	386+
JS rel8	o64 78 cb	X64
JS rel16	o16 0F 88 cw	386+
JS rel32	o32 0F 88 cd	386+
JS rel32	o64 0F 88 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn jz<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmJz<T>, 

JZ instruction

Instruction	Opcode	CPUID
JE rel8	o16 74 cb	8086+
JE rel8	o32 74 cb	386+
JE rel8	o64 74 cb	X64
JE rel16	o16 0F 84 cw	386+
JE rel32	o32 0F 84 cd	386+
JE rel32	o64 0F 84 cd	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn kaddb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKaddb<T, U, V>, 

KADDB instruction

Instruction	Opcode	CPUID
KADDB k1, k2, k3	VEX.L1.66.0F.W0 4A /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kaddd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKaddd<T, U, V>, 

KADDD instruction

Instruction	Opcode	CPUID
KADDD k1, k2, k3	VEX.L1.66.0F.W1 4A /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kaddq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKaddq<T, U, V>, 

KADDQ instruction

Instruction	Opcode	CPUID
KADDQ k1, k2, k3	VEX.L1.0F.W1 4A /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kaddw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKaddw<T, U, V>, 

KADDW instruction

Instruction	Opcode	CPUID
KADDW k1, k2, k3	VEX.L1.0F.W0 4A /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kandb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKandb<T, U, V>, 

KANDB instruction

Instruction	Opcode	CPUID
KANDB k1, k2, k3	VEX.L1.66.0F.W0 41 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kandd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKandd<T, U, V>, 

KANDD instruction

Instruction	Opcode	CPUID
KANDD k1, k2, k3	VEX.L1.66.0F.W1 41 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kandnb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKandnb<T, U, V>, 

KANDNB instruction

Instruction	Opcode	CPUID
KANDNB k1, k2, k3	VEX.L1.66.0F.W0 42 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kandnd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKandnd<T, U, V>, 

KANDND instruction

Instruction	Opcode	CPUID
KANDND k1, k2, k3	VEX.L1.66.0F.W1 42 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kandnq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKandnq<T, U, V>, 

KANDNQ instruction

Instruction	Opcode	CPUID
KANDNQ k1, k2, k3	VEX.L1.0F.W1 42 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kandnw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKandnw<T, U, V>, 

KANDNW instruction

Instruction	Opcode	CPUID
KANDNW k1, k2, k3	VEX.L1.0F.W0 42 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kandq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKandq<T, U, V>, 

KANDQ instruction

Instruction	Opcode	CPUID
KANDQ k1, k2, k3	VEX.L1.0F.W1 41 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kandw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKandw<T, U, V>, 

KANDW instruction

Instruction	Opcode	CPUID
KANDW k1, k2, k3	VEX.L1.0F.W0 41 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kmovb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKmovb<T, U>, 

KMOVB instruction

Instruction	Opcode	CPUID
KMOVB k1, k2/m8	VEX.L0.66.0F.W0 90 /r	AVX512DQ
KMOVB m8, k1	VEX.L0.66.0F.W0 91 /r	AVX512DQ
KMOVB k1, r32	VEX.L0.66.0F.W0 92 /r	AVX512DQ
KMOVB r32, k1	VEX.L0.66.0F.W0 93 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn kmovd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKmovd<T, U>, 

KMOVD instruction

Instruction	Opcode	CPUID
KMOVD k1, k2/m32	VEX.L0.66.0F.W1 90 /r	AVX512BW
KMOVD m32, k1	VEX.L0.66.0F.W1 91 /r	AVX512BW
KMOVD k1, r32	VEX.L0.F2.0F.W0 92 /r	AVX512BW
KMOVD r32, k1	VEX.L0.F2.0F.W0 93 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn kmovq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKmovq<T, U>, 

KMOVQ instruction

Instruction	Opcode	CPUID
KMOVQ k1, k2/m64	VEX.L0.0F.W1 90 /r	AVX512BW
KMOVQ m64, k1	VEX.L0.0F.W1 91 /r	AVX512BW
KMOVQ k1, r64	VEX.L0.F2.0F.W1 92 /r	AVX512BW
KMOVQ r64, k1	VEX.L0.F2.0F.W1 93 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn kmovw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKmovw<T, U>, 

KMOVW instruction

Instruction	Opcode	CPUID
KMOVW k1, k2/m16	VEX.L0.0F.W0 90 /r	AVX512F
KMOVW m16, k1	VEX.L0.0F.W0 91 /r	AVX512F
KMOVW k1, r32	VEX.L0.0F.W0 92 /r	AVX512F
KMOVW r32, k1	VEX.L0.0F.W0 93 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn knotb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKnotb<T, U>, 

KNOTB instruction

Instruction	Opcode	CPUID
KNOTB k1, k2	VEX.L0.66.0F.W0 44 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn knotd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKnotd<T, U>, 

KNOTD instruction

Instruction	Opcode	CPUID
KNOTD k1, k2	VEX.L0.66.0F.W1 44 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn knotq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKnotq<T, U>, 

KNOTQ instruction

Instruction	Opcode	CPUID
KNOTQ k1, k2	VEX.L0.0F.W1 44 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn knotw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKnotw<T, U>, 

KNOTW instruction

Instruction	Opcode	CPUID
KNOTW k1, k2	VEX.L0.0F.W0 44 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn korb<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmKorb<T, U, V>, 

KORB instruction

Instruction	Opcode	CPUID
KORB k1, k2, k3	VEX.L1.66.0F.W0 45 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kord<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmKord<T, U, V>, 

KORD instruction

Instruction	Opcode	CPUID
KORD k1, k2, k3	VEX.L1.66.0F.W1 45 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn korq<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmKorq<T, U, V>, 

KORQ instruction

Instruction	Opcode	CPUID
KORQ k1, k2, k3	VEX.L1.0F.W1 45 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kortestb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKortestb<T, U>, 

KORTESTB instruction

Instruction	Opcode	CPUID
KORTESTB k1, k2	VEX.L0.66.0F.W0 98 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn kortestd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKortestd<T, U>, 

KORTESTD instruction

Instruction	Opcode	CPUID
KORTESTD k1, k2	VEX.L0.66.0F.W1 98 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn kortestq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKortestq<T, U>, 

KORTESTQ instruction

Instruction	Opcode	CPUID
KORTESTQ k1, k2	VEX.L0.0F.W1 98 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn kortestw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKortestw<T, U>, 

KORTESTW instruction

Instruction	Opcode	CPUID
KORTESTW k1, k2	VEX.L0.0F.W0 98 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn korw<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmKorw<T, U, V>, 

KORW instruction

Instruction	Opcode	CPUID
KORW k1, k2, k3	VEX.L1.0F.W0 45 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kshiftlb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKshiftlb<T, U, V>, 

KSHIFTLB instruction

Instruction	Opcode	CPUID
KSHIFTLB k1, k2, imm8	VEX.L0.66.0F3A.W0 32 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kshiftld<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKshiftld<T, U, V>, 

KSHIFTLD instruction

Instruction	Opcode	CPUID
KSHIFTLD k1, k2, imm8	VEX.L0.66.0F3A.W0 33 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kshiftlq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKshiftlq<T, U, V>, 

KSHIFTLQ instruction

Instruction	Opcode	CPUID
KSHIFTLQ k1, k2, imm8	VEX.L0.66.0F3A.W1 33 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kshiftlw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKshiftlw<T, U, V>, 

KSHIFTLW instruction

Instruction	Opcode	CPUID
KSHIFTLW k1, k2, imm8	VEX.L0.66.0F3A.W1 32 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kshiftrb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKshiftrb<T, U, V>, 

KSHIFTRB instruction

Instruction	Opcode	CPUID
KSHIFTRB k1, k2, imm8	VEX.L0.66.0F3A.W0 30 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kshiftrd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKshiftrd<T, U, V>, 

KSHIFTRD instruction

Instruction	Opcode	CPUID
KSHIFTRD k1, k2, imm8	VEX.L0.66.0F3A.W0 31 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kshiftrq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKshiftrq<T, U, V>, 

KSHIFTRQ instruction

Instruction	Opcode	CPUID
KSHIFTRQ k1, k2, imm8	VEX.L0.66.0F3A.W1 31 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kshiftrw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKshiftrw<T, U, V>, 

KSHIFTRW instruction

Instruction	Opcode	CPUID
KSHIFTRW k1, k2, imm8	VEX.L0.66.0F3A.W1 30 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn ktestb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKtestb<T, U>, 

KTESTB instruction

Instruction	Opcode	CPUID
KTESTB k1, k2	VEX.L0.66.0F.W0 99 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ktestd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKtestd<T, U>, 

KTESTD instruction

Instruction	Opcode	CPUID
KTESTD k1, k2	VEX.L0.66.0F.W1 99 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ktestq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKtestq<T, U>, 

KTESTQ instruction

Instruction	Opcode	CPUID
KTESTQ k1, k2	VEX.L0.0F.W1 99 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ktestw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmKtestw<T, U>, 

KTESTW instruction

Instruction	Opcode	CPUID
KTESTW k1, k2	VEX.L0.0F.W0 99 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn kunpckbw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKunpckbw<T, U, V>, 

KUNPCKBW instruction

Instruction	Opcode	CPUID
KUNPCKBW k1, k2, k3	VEX.L1.66.0F.W0 4B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kunpckdq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKunpckdq<T, U, V>, 

KUNPCKDQ instruction

Instruction	Opcode	CPUID
KUNPCKDQ k1, k2, k3	VEX.L1.0F.W1 4B /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kunpckwd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKunpckwd<T, U, V>, 

KUNPCKWD instruction

Instruction	Opcode	CPUID
KUNPCKWD k1, k2, k3	VEX.L1.0F.W0 4B /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kxnorb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKxnorb<T, U, V>, 

KXNORB instruction

Instruction	Opcode	CPUID
KXNORB k1, k2, k3	VEX.L1.66.0F.W0 46 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kxnord<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKxnord<T, U, V>, 

KXNORD instruction

Instruction	Opcode	CPUID
KXNORD k1, k2, k3	VEX.L1.66.0F.W1 46 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kxnorq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKxnorq<T, U, V>, 

KXNORQ instruction

Instruction	Opcode	CPUID
KXNORQ k1, k2, k3	VEX.L1.0F.W1 46 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kxnorw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKxnorw<T, U, V>, 

KXNORW instruction

Instruction	Opcode	CPUID
KXNORW k1, k2, k3	VEX.L1.0F.W0 46 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kxorb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKxorb<T, U, V>, 

KXORB instruction

Instruction	Opcode	CPUID
KXORB k1, k2, k3	VEX.L1.66.0F.W0 47 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kxord<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKxord<T, U, V>, 

KXORD instruction

Instruction	Opcode	CPUID
KXORD k1, k2, k3	VEX.L1.66.0F.W1 47 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kxorq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKxorq<T, U, V>, 

KXORQ instruction

Instruction	Opcode	CPUID
KXORQ k1, k2, k3	VEX.L1.0F.W1 47 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn kxorw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmKxorw<T, U, V>, 

KXORW instruction

Instruction	Opcode	CPUID
KXORW k1, k2, k3	VEX.L1.0F.W0 47 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn lahf(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmLahf, 

LAHF instruction

Instruction	Opcode	CPUID
LAHF	9F	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn lar<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLar<T, U>, 

LAR instruction

Instruction	Opcode	CPUID
LAR r16, r/m16	o16 0F 02 /r	286+
LAR r32, r32/m16	o32 0F 02 /r	386+
LAR r64, r64/m16	o64 0F 02 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn lddqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLddqu<T, U>, 

LDDQU instruction

Instruction	Opcode	CPUID
LDDQU xmm1, m128	F2 0F F0 /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ldmxcsr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLdmxcsr<T>, 

LDMXCSR instruction

Instruction	Opcode	CPUID
LDMXCSR m32	NP 0F AE /2	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn lds<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLds<T, U>, 

LDS instruction

Instruction	Opcode	CPUID
LDS r16, m16:16	o16 C5 /r	8086+
LDS r32, m16:32	o32 C5 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ldtilecfg<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLdtilecfg<T>, 

LDTILECFG instruction

Instruction	Opcode	CPUID
LDTILECFG m512	VEX.128.0F38.W0 49 !(11):000:bbb	AMX-TILE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn lea<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLea<T, U>, 

LEA instruction

Instruction	Opcode	CPUID
LEA r16, m	o16 8D /r	8086+
LEA r32, m	o32 8D /r	386+
LEA r64, m	o64 8D /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn leave(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmLeave, 

LEAVE instruction

Instruction	Opcode	CPUID
LEAVE	o16 C9	186+
LEAVE	o32 C9	386+
LEAVE	o64 C9	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn les<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLes<T, U>, 

LES instruction

Instruction	Opcode	CPUID
LES r16, m16:16	o16 C4 /r	8086+
LES r32, m16:32	o32 C4 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn lfence(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmLfence, 

LFENCE instruction

Instruction	Opcode	CPUID
LFENCE	NP 0F AE E8	SSE2

Errors

Fails if an operand is invalid (basic checks only)

pub fn lfs<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLfs<T, U>, 

LFS instruction

Instruction	Opcode	CPUID
LFS r16, m16:16	o16 0F B4 /r	386+
LFS r32, m16:32	o32 0F B4 /r	386+
LFS r64, m16:64	o64 0F B4 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn lgdt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLgdt<T>, 

LGDT instruction

Instruction	Opcode	CPUID
LGDT m16&64	0F 01 /2	X64
LGDT m16&32	o16 0F 01 /2	286+
LGDT m16&32	o32 0F 01 /2	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn lgs<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLgs<T, U>, 

LGS instruction

Instruction	Opcode	CPUID
LGS r16, m16:16	o16 0F B5 /r	386+
LGS r32, m16:32	o32 0F B5 /r	386+
LGS r64, m16:64	o64 0F B5 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn lidt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLidt<T>, 

LIDT instruction

Instruction	Opcode	CPUID
LIDT m16&64	0F 01 /3	X64
LIDT m16&32	o16 0F 01 /3	286+
LIDT m16&32	o32 0F 01 /3	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn lkgs<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLkgs<T>, 

LKGS instruction

Instruction	Opcode	CPUID
LKGS r/m16	o16 F2 0F 00 /6	LKGS
LKGS r32/m16	o32 F2 0F 00 /6	LKGS
LKGS r64/m16	F2 o64 0F 00 /6	LKGS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn lldt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLldt<T>, 

LLDT instruction

Instruction	Opcode	CPUID
LLDT r/m16	o16 0F 00 /2	286+
LLDT r32/m16	o32 0F 00 /2	386+
LLDT r64/m16	o64 0F 00 /2	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn llwpcb<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLlwpcb<T>, 

LLWPCB instruction

Instruction	Opcode	CPUID
LLWPCB r32	XOP.L0.X9.W0 12 /0	LWP
LLWPCB r64	XOP.L0.X9.W1 12 /0	LWP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn lmsw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLmsw<T>, 

LMSW instruction

Instruction	Opcode	CPUID
LMSW r/m16	o16 0F 01 /6	286+
LMSW r32/m16	o32 0F 01 /6	386+
LMSW r64/m16	o64 0F 01 /6	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn loadall(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmLoadall, 

LOADALL instruction

Instruction	Opcode	CPUID
LOADALL	0F 07	386

Errors

Fails if an operand is invalid (basic checks only)

pub fn loadiwkey<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLoadiwkey<T, U>, 

LOADIWKEY instruction

Instruction	Opcode	CPUID
LOADIWKEY xmm1, xmm2, <EAX>, <XMM0>	F3 0F 38 DC 11:rrr:bbb	KL

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn lodsb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmLodsb, 

LODSB instruction

Instruction	Opcode	CPUID
LODSB	AC	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn lodsd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmLodsd, 

LODSD instruction

Instruction	Opcode	CPUID
LODSD	o32 AD	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn lodsq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmLodsq, 

LODSQ instruction

Instruction	Opcode	CPUID
LODSQ	o64 AD	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn lodsw(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmLodsw, 

LODSW instruction

Instruction	Opcode	CPUID
LODSW	o16 AD	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn loop_<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLoop<T>, 

LOOP instruction

Instruction	Opcode	CPUID
LOOP rel8	a16 o16 E2 cb	8086+
LOOP rel8	a32 o32 E2 cb	386+
LOOP rel8	a64 o64 E2 cb	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn loope<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLoope<T>, 

LOOPE instruction

Instruction	Opcode	CPUID
LOOPE rel8	a16 o16 E1 cb	8086+
LOOPE rel8	a32 o32 E1 cb	386+
LOOPE rel8	a64 o64 E1 cb	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn loopne<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLoopne<T>, 

LOOPNE instruction

Instruction	Opcode	CPUID
LOOPNE rel8	a16 o16 E0 cb	8086+
LOOPNE rel8	a32 o32 E0 cb	386+
LOOPNE rel8	a64 o64 E0 cb	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn loopnz<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLoopnz<T>, 

LOOPNZ instruction

Instruction	Opcode	CPUID
LOOPNE rel8	a16 o16 E0 cb	8086+
LOOPNE rel8	a32 o32 E0 cb	386+
LOOPNE rel8	a64 o64 E0 cb	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn loopz<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLoopz<T>, 

LOOPZ instruction

Instruction	Opcode	CPUID
LOOPE rel8	a16 o16 E1 cb	8086+
LOOPE rel8	a32 o32 E1 cb	386+
LOOPE rel8	a64 o64 E1 cb	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn lsl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLsl<T, U>, 

LSL instruction

Instruction	Opcode	CPUID
LSL r16, r/m16	o16 0F 03 /r	286+
LSL r32, r32/m16	o32 0F 03 /r	386+
LSL r64, r64/m16	o64 0F 03 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn lss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLss<T, U>, 

LSS instruction

Instruction	Opcode	CPUID
LSS r16, m16:16	o16 0F B2 /r	386+
LSS r32, m16:32	o32 0F B2 /r	386+
LSS r64, m16:64	o64 0F B2 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ltr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmLtr<T>, 

LTR instruction

Instruction	Opcode	CPUID
LTR r/m16	o16 0F 00 /3	286+
LTR r32/m16	o32 0F 00 /3	386+
LTR r64/m16	o64 0F 00 /3	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn lwpins<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmLwpins<T, U, V>, 

LWPINS instruction

Instruction	Opcode	CPUID
LWPINS r32, r/m32, imm32	XOP.L0.XA.W0 12 /0 id	LWP
LWPINS r64, r/m32, imm32	XOP.L0.XA.W1 12 /0 id	LWP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn lwpval<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmLwpval<T, U, V>, 

LWPVAL instruction

Instruction	Opcode	CPUID
LWPVAL r32, r/m32, imm32	XOP.L0.XA.W0 12 /1 id	LWP
LWPVAL r64, r/m32, imm32	XOP.L0.XA.W1 12 /1 id	LWP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn lzcnt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmLzcnt<T, U>, 

LZCNT instruction

Instruction	Opcode	CPUID
LZCNT r16, r/m16	o16 F3 0F BD /r	LZCNT
LZCNT r32, r/m32	o32 F3 0F BD /r	LZCNT
LZCNT r64, r/m64	F3 o64 0F BD /r	LZCNT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn maskmovdqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMaskmovdqu<T, U>, 

MASKMOVDQU instruction

Instruction	Opcode	CPUID
MASKMOVDQU xmm1, xmm2	66 0F F7 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn maskmovq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMaskmovq<T, U>, 

MASKMOVQ instruction

Instruction	Opcode	CPUID
MASKMOVQ mm1, mm2	NP 0F F7 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn maxpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMaxpd<T, U>, 

MAXPD instruction

Instruction	Opcode	CPUID
MAXPD xmm1, xmm2/m128	66 0F 5F /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn maxps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMaxps<T, U>, 

MAXPS instruction

Instruction	Opcode	CPUID
MAXPS xmm1, xmm2/m128	NP 0F 5F /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn maxsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMaxsd<T, U>, 

MAXSD instruction

Instruction	Opcode	CPUID
MAXSD xmm1, xmm2/m64	F2 0F 5F /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn maxss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMaxss<T, U>, 

MAXSS instruction

Instruction	Opcode	CPUID
MAXSS xmm1, xmm2/m32	F3 0F 5F /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn mcommit(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMcommit, 

MCOMMIT instruction

Instruction	Opcode	CPUID
MCOMMIT	F3 0F 01 FA	MCOMMIT

Errors

Fails if an operand is invalid (basic checks only)

pub fn mfence(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMfence, 

MFENCE instruction

Instruction	Opcode	CPUID
MFENCE	NP 0F AE F0	SSE2

Errors

Fails if an operand is invalid (basic checks only)

pub fn minpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMinpd<T, U>, 

MINPD instruction

Instruction	Opcode	CPUID
MINPD xmm1, xmm2/m128	66 0F 5D /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn minps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMinps<T, U>, 

MINPS instruction

Instruction	Opcode	CPUID
MINPS xmm1, xmm2/m128	NP 0F 5D /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn minsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMinsd<T, U>, 

MINSD instruction

Instruction	Opcode	CPUID
MINSD xmm1, xmm2/m64	F2 0F 5D /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn minss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMinss<T, U>, 

MINSS instruction

Instruction	Opcode	CPUID
MINSS xmm1, xmm2/m32	F3 0F 5D /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn monitor(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMonitor, 

MONITOR instruction

Instruction	Opcode	CPUID
MONITOR	a16 NP 0F 01 C8	MONITOR
MONITOR	a32 NP 0F 01 C8	MONITOR
MONITOR	a64 NP 0F 01 C8	MONITOR

Errors

Fails if an operand is invalid (basic checks only)

pub fn monitorx(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMonitorx, 

MONITORX instruction

Instruction	Opcode	CPUID
MONITORX	a16 NP 0F 01 FA	MONITORX
MONITORX	a32 NP 0F 01 FA	MONITORX
MONITORX	a64 NP 0F 01 FA	MONITORX

Errors

Fails if an operand is invalid (basic checks only)

pub fn montmul(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMontmul, 

MONTMUL instruction

Instruction	Opcode	CPUID
MONTMUL	a16 F3 0F A6 C0	PADLOCK_PMM
MONTMUL	a32 F3 0F A6 C0	PADLOCK_PMM
MONTMUL	a64 F3 0F A6 C0	PADLOCK_PMM

Errors

Fails if an operand is invalid (basic checks only)

pub fn mov<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMov<T, U>, 

MOV instruction

Instruction	Opcode	CPUID
MOV r/m8, r8	88 /r	8086+
MOV r/m16, r16	o16 89 /r	8086+
MOV r/m32, r32	o32 89 /r	386+
MOV r/m64, r64	o64 89 /r	X64
MOV r8, r/m8	8A /r	8086+
MOV r16, r/m16	o16 8B /r	8086+
MOV r32, r/m32	o32 8B /r	386+
MOV r64, r/m64	o64 8B /r	X64
MOV r/m16, Sreg	o16 8C /r	8086+
MOV r32/m16, Sreg	o32 8C /r	386+
MOV r64/m16, Sreg	o64 8C /r	X64
MOV Sreg, r/m16	o16 8E /r	8086+
MOV Sreg, r32/m16	o32 8E /r	386+
MOV Sreg, r64/m16	o64 8E /r	X64
MOV AL, moffs8	A0 mo	8086+
MOV AX, moffs16	o16 A1 mo	8086+
MOV EAX, moffs32	o32 A1 mo	386+
MOV RAX, moffs64	o64 A1 mo	X64
MOV moffs8, AL	A2 mo	8086+
MOV moffs16, AX	o16 A3 mo	8086+
MOV moffs32, EAX	o32 A3 mo	386+
MOV moffs64, RAX	o64 A3 mo	X64
MOV r8, imm8	B0+rb ib	8086+
MOV r16, imm16	o16 B8+rw iw	8086+
MOV r32, imm32	o32 B8+rd id	386+
MOV r64, imm64	o64 B8+ro io	X64
MOV r/m8, imm8	C6 /0 ib	8086+
MOV r/m16, imm16	o16 C7 /0 iw	8086+
MOV r/m32, imm32	o32 C7 /0 id	386+
MOV r/m64, imm32	o64 C7 /0 id	X64
MOV r32, cr	0F 20 /r	386+
MOV r64, cr	0F 20 /r	X64
MOV r32, dr	0F 21 /r	386+
MOV r64, dr	0F 21 /r	X64
MOV cr, r32	0F 22 /r	386+
MOV cr, r64	0F 22 /r	X64
MOV dr, r32	0F 23 /r	386+
MOV dr, r64	0F 23 /r	X64
MOV r32, tr	0F 24 /r	386/486/Cyrix/Geode
MOV tr, r32	0F 26 /r	386/486/Cyrix/Geode

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movapd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovapd<T, U>, 

MOVAPD instruction

Instruction	Opcode	CPUID
MOVAPD xmm1, xmm2/m128	66 0F 28 /r	SSE2
MOVAPD xmm2/m128, xmm1	66 0F 29 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movaps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovaps<T, U>, 

MOVAPS instruction

Instruction	Opcode	CPUID
MOVAPS xmm1, xmm2/m128	NP 0F 28 /r	SSE
MOVAPS xmm2/m128, xmm1	NP 0F 29 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movbe<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovbe<T, U>, 

MOVBE instruction

Instruction	Opcode	CPUID
MOVBE r16, m16	o16 0F 38 F0 /r	MOVBE
MOVBE r32, m32	o32 0F 38 F0 /r	MOVBE
MOVBE r64, m64	o64 0F 38 F0 /r	MOVBE
MOVBE m16, r16	o16 0F 38 F1 /r	MOVBE
MOVBE m32, r32	o32 0F 38 F1 /r	MOVBE
MOVBE m64, r64	o64 0F 38 F1 /r	MOVBE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovd<T, U>, 

MOVD instruction

Instruction	Opcode	CPUID
MOVD mm, r/m32	NP 0F 6E /r	MMX
MOVD xmm, r/m32	66 0F 6E /r	SSE2
MOVD r/m32, mm	NP 0F 7E /r	MMX
MOVD r/m32, xmm	66 0F 7E /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movddup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovddup<T, U>, 

MOVDDUP instruction

Instruction	Opcode	CPUID
MOVDDUP xmm1, xmm2/m64	F2 0F 12 /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movdir64b<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovdir64b<T, U>, 

MOVDIR64B instruction

Instruction	Opcode	CPUID
MOVDIR64B r16, m512	a16 66 0F 38 F8 /r	MOVDIR64B
MOVDIR64B r32, m512	a32 66 0F 38 F8 /r	MOVDIR64B
MOVDIR64B r64, m512	a64 66 0F 38 F8 /r	MOVDIR64B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movdiri<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovdiri<T, U>, 

MOVDIRI instruction

Instruction	Opcode	CPUID
MOVDIRI m32, r32	NP 0F 38 F9 /r	MOVDIRI
MOVDIRI m64, r64	NP o64 0F 38 F9 /r	MOVDIRI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movdq2q<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovdq2q<T, U>, 

MOVDQ2Q instruction

Instruction	Opcode	CPUID
MOVDQ2Q mm, xmm	F2 0F D6 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movdqa<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovdqa<T, U>, 

MOVDQA instruction

Instruction	Opcode	CPUID
MOVDQA xmm1, xmm2/m128	66 0F 6F /r	SSE2
MOVDQA xmm2/m128, xmm1	66 0F 7F /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movdqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovdqu<T, U>, 

MOVDQU instruction

Instruction	Opcode	CPUID
MOVDQU xmm1, xmm2/m128	F3 0F 6F /r	SSE2
MOVDQU xmm2/m128, xmm1	F3 0F 7F /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movhlps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovhlps<T, U>, 

MOVHLPS instruction

Instruction	Opcode	CPUID
MOVHLPS xmm1, xmm2	NP 0F 12 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movhpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovhpd<T, U>, 

MOVHPD instruction

Instruction	Opcode	CPUID
MOVHPD xmm1, m64	66 0F 16 /r	SSE2
MOVHPD m64, xmm1	66 0F 17 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movhps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovhps<T, U>, 

MOVHPS instruction

Instruction	Opcode	CPUID
MOVHPS xmm1, m64	NP 0F 16 /r	SSE
MOVHPS m64, xmm1	NP 0F 17 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movlhps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovlhps<T, U>, 

MOVLHPS instruction

Instruction	Opcode	CPUID
MOVLHPS xmm1, xmm2	NP 0F 16 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movlpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovlpd<T, U>, 

MOVLPD instruction

Instruction	Opcode	CPUID
MOVLPD xmm1, m64	66 0F 12 /r	SSE2
MOVLPD m64, xmm1	66 0F 13 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movlps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovlps<T, U>, 

MOVLPS instruction

Instruction	Opcode	CPUID
MOVLPS xmm1, m64	NP 0F 12 /r	SSE
MOVLPS m64, xmm1	NP 0F 13 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movmskpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovmskpd<T, U>, 

MOVMSKPD instruction

Instruction	Opcode	CPUID
MOVMSKPD r32, xmm	66 0F 50 /r	SSE2
MOVMSKPD r64, xmm	66 o64 0F 50 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movmskps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovmskps<T, U>, 

MOVMSKPS instruction

Instruction	Opcode	CPUID
MOVMSKPS r32, xmm	NP 0F 50 /r	SSE
MOVMSKPS r64, xmm	NP o64 0F 50 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movntdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovntdq<T, U>, 

MOVNTDQ instruction

Instruction	Opcode	CPUID
MOVNTDQ m128, xmm1	66 0F E7 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movntdqa<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovntdqa<T, U>, 

MOVNTDQA instruction

Instruction	Opcode	CPUID
MOVNTDQA xmm1, m128	66 0F 38 2A /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movnti<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovnti<T, U>, 

MOVNTI instruction

Instruction	Opcode	CPUID
MOVNTI m32, r32	NP 0F C3 /r	SSE2
MOVNTI m64, r64	NP o64 0F C3 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movntpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovntpd<T, U>, 

MOVNTPD instruction

Instruction	Opcode	CPUID
MOVNTPD m128, xmm1	66 0F 2B /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movntps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovntps<T, U>, 

MOVNTPS instruction

Instruction	Opcode	CPUID
MOVNTPS m128, xmm1	NP 0F 2B /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movntq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovntq<T, U>, 

MOVNTQ instruction

Instruction	Opcode	CPUID
MOVNTQ m64, mm	NP 0F E7 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movntsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovntsd<T, U>, 

MOVNTSD instruction

Instruction	Opcode	CPUID
MOVNTSD m64, xmm1	F2 0F 2B /r	SSE4A

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movntss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovntss<T, U>, 

MOVNTSS instruction

Instruction	Opcode	CPUID
MOVNTSS m32, xmm1	F3 0F 2B /r	SSE4A

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovq<T, U>, 

MOVQ instruction

Instruction	Opcode	CPUID
MOVQ mm, r/m64	NP o64 0F 6E /r	MMX
MOVQ xmm, r/m64	66 o64 0F 6E /r	SSE2
MOVQ mm, mm/m64	NP 0F 6F /r	MMX
MOVQ r/m64, mm	NP o64 0F 7E /r	MMX
MOVQ r/m64, xmm	66 o64 0F 7E /r	SSE2
MOVQ xmm1, xmm2/m64	F3 0F 7E /r	SSE2
MOVQ mm/m64, mm	NP 0F 7F /r	MMX
MOVQ xmm2/m64, xmm1	66 0F D6 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movq2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovq2dq<T, U>, 

MOVQ2DQ instruction

Instruction	Opcode	CPUID
MOVQ2DQ xmm, mm	F3 0F D6 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movsb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMovsb, 

MOVSB instruction

Instruction	Opcode	CPUID
MOVSB	A4	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn movsd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMovsd, 

MOVSD instruction

Instruction	Opcode	CPUID
MOVSD	o32 A5	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn movsd_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovsd2<T, U>, 

MOVSD instruction

Instruction	Opcode	CPUID
MOVSD xmm1, xmm2/m64	F2 0F 10 /r	SSE2
MOVSD xmm1/m64, xmm2	F2 0F 11 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movshdup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovshdup<T, U>, 

MOVSHDUP instruction

Instruction	Opcode	CPUID
MOVSHDUP xmm1, xmm2/m128	F3 0F 16 /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movsldup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovsldup<T, U>, 

MOVSLDUP instruction

Instruction	Opcode	CPUID
MOVSLDUP xmm1, xmm2/m128	F3 0F 12 /r	SSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movsq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMovsq, 

MOVSQ instruction

Instruction	Opcode	CPUID
MOVSQ	o64 A5	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn movss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovss<T, U>, 

MOVSS instruction

Instruction	Opcode	CPUID
MOVSS xmm1, xmm2/m32	F3 0F 10 /r	SSE
MOVSS xmm2/m32, xmm1	F3 0F 11 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movsw(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMovsw, 

MOVSW instruction

Instruction	Opcode	CPUID
MOVSW	o16 A5	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn movsx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovsx<T, U>, 

MOVSX instruction

Instruction	Opcode	CPUID
MOVSX r16, r/m8	o16 0F BE /r	386+
MOVSX r32, r/m8	o32 0F BE /r	386+
MOVSX r64, r/m8	o64 0F BE /r	X64
MOVSX r16, r/m16	o16 0F BF /r	386+
MOVSX r32, r/m16	o32 0F BF /r	386+
MOVSX r64, r/m16	o64 0F BF /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movsxd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovsxd<T, U>, 

MOVSXD instruction

Instruction	Opcode	CPUID
MOVSXD r16, r/m16	o16 63 /r	X64
MOVSXD r32, r/m32	o32 63 /r	X64
MOVSXD r64, r/m32	o64 63 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movupd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovupd<T, U>, 

MOVUPD instruction

Instruction	Opcode	CPUID
MOVUPD xmm1, xmm2/m128	66 0F 10 /r	SSE2
MOVUPD xmm2/m128, xmm1	66 0F 11 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movups<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovups<T, U>, 

MOVUPS instruction

Instruction	Opcode	CPUID
MOVUPS xmm1, xmm2/m128	NP 0F 10 /r	SSE
MOVUPS xmm2/m128, xmm1	NP 0F 11 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn movzx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMovzx<T, U>, 

MOVZX instruction

Instruction	Opcode	CPUID
MOVZX r16, r/m8	o16 0F B6 /r	386+
MOVZX r32, r/m8	o32 0F B6 /r	386+
MOVZX r64, r/m8	o64 0F B6 /r	X64
MOVZX r16, r/m16	o16 0F B7 /r	386+
MOVZX r32, r/m16	o32 0F B7 /r	386+
MOVZX r64, r/m16	o64 0F B7 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn mpsadbw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmMpsadbw<T, U, V>, 

MPSADBW instruction

Instruction	Opcode	CPUID
MPSADBW xmm1, xmm2/m128, imm8	66 0F 3A 42 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn mul<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmMul<T>, 

MUL instruction

Instruction	Opcode	CPUID
MUL r/m8	F6 /4	8086+
MUL r/m16	o16 F7 /4	8086+
MUL r/m32	o32 F7 /4	386+
MUL r/m64	o64 F7 /4	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn mulpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMulpd<T, U>, 

MULPD instruction

Instruction	Opcode	CPUID
MULPD xmm1, xmm2/m128	66 0F 59 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn mulps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMulps<T, U>, 

MULPS instruction

Instruction	Opcode	CPUID
MULPS xmm1, xmm2/m128	NP 0F 59 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn mulsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMulsd<T, U>, 

MULSD instruction

Instruction	Opcode	CPUID
MULSD xmm1, xmm2/m64	F2 0F 59 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn mulss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmMulss<T, U>, 

MULSS instruction

Instruction	Opcode	CPUID
MULSS xmm1, xmm2/m32	F3 0F 59 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn mulx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmMulx<T, U, V>, 

MULX instruction

Instruction	Opcode	CPUID
MULX r32a, r32b, r/m32	VEX.LZ.F2.0F38.W0 F6 /r	BMI2
MULX r64a, r64b, r/m64	VEX.LZ.F2.0F38.W1 F6 /r	BMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn mwait(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMwait, 

MWAIT instruction

Instruction	Opcode	CPUID
MWAIT	NP 0F 01 C9	MONITOR

Errors

Fails if an operand is invalid (basic checks only)

pub fn mwaitx(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmMwaitx, 

MWAITX instruction

Instruction	Opcode	CPUID
MWAITX	NP 0F 01 FB	MONITORX

Errors

Fails if an operand is invalid (basic checks only)

pub fn neg<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmNeg<T>, 

NEG instruction

Instruction	Opcode	CPUID
NEG r/m8	F6 /3	8086+
NEG r/m16	o16 F7 /3	8086+
NEG r/m32	o32 F7 /3	386+
NEG r/m64	o64 F7 /3	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn nop(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmNop, 

NOP instruction

Instruction	Opcode	CPUID
NOP	o16 90	8086+
NOP	o32 90	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn nop_1<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmNop1<T>, 

NOP instruction

Instruction	Opcode	CPUID
NOP r/m16	o16 0F 1F /0	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
NOP r/m32	o32 0F 1F /0	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
NOP r/m64	o64 0F 1F /0	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn not<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmNot<T>, 

NOT instruction

Instruction	Opcode	CPUID
NOT r/m8	F6 /2	8086+
NOT r/m16	o16 F7 /2	8086+
NOT r/m32	o32 F7 /2	386+
NOT r/m64	o64 F7 /2	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn or<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmOr<T, U>, 

OR instruction

Instruction	Opcode	CPUID
OR r/m8, r8	08 /r	8086+
OR r/m16, r16	o16 09 /r	8086+
OR r/m32, r32	o32 09 /r	386+
OR r/m64, r64	o64 09 /r	X64
OR r8, r/m8	0A /r	8086+
OR r16, r/m16	o16 0B /r	8086+
OR r32, r/m32	o32 0B /r	386+
OR r64, r/m64	o64 0B /r	X64
OR AL, imm8	0C ib	8086+
OR AX, imm16	o16 0D iw	8086+
OR EAX, imm32	o32 0D id	386+
OR RAX, imm32	o64 0D id	X64
OR r/m8, imm8	80 /1 ib	8086+
OR r/m16, imm16	o16 81 /1 iw	8086+
OR r/m32, imm32	o32 81 /1 id	386+
OR r/m64, imm32	o64 81 /1 id	X64
OR r/m16, imm8	o16 83 /1 ib	8086+
OR r/m32, imm8	o32 83 /1 ib	386+
OR r/m64, imm8	o64 83 /1 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn orpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmOrpd<T, U>, 

ORPD instruction

Instruction	Opcode	CPUID
ORPD xmm1, xmm2/m128	66 0F 56 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn orps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmOrps<T, U>, 

ORPS instruction

Instruction	Opcode	CPUID
ORPS xmm1, xmm2/m128	NP 0F 56 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn out<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmOut<T, U>, 

OUT instruction

Instruction	Opcode	CPUID
OUT imm8, AL	E6 ib	8086+
OUT imm8, AX	o16 E7 ib	8086+
OUT imm8, EAX	o32 E7 ib	386+
OUT DX, AL	EE	8086+
OUT DX, AX	o16 EF	8086+
OUT DX, EAX	o32 EF	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn outsb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmOutsb, 

OUTSB instruction

Instruction	Opcode	CPUID
OUTSB	6E	186+

Errors

Fails if an operand is invalid (basic checks only)

pub fn outsd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmOutsd, 

OUTSD instruction

Instruction	Opcode	CPUID
OUTSD	o32 6F	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn outsw(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmOutsw, 

OUTSW instruction

Instruction	Opcode	CPUID
OUTSW	o16 6F	186+

Errors

Fails if an operand is invalid (basic checks only)

pub fn pabsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPabsb<T, U>, 

PABSB instruction

Instruction	Opcode	CPUID
PABSB mm1, mm2/m64	NP 0F 38 1C /r	SSSE3
PABSB xmm1, xmm2/m128	66 0F 38 1C /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pabsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPabsd<T, U>, 

PABSD instruction

Instruction	Opcode	CPUID
PABSD mm1, mm2/m64	NP 0F 38 1E /r	SSSE3
PABSD xmm1, xmm2/m128	66 0F 38 1E /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pabsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPabsw<T, U>, 

PABSW instruction

Instruction	Opcode	CPUID
PABSW mm1, mm2/m64	NP 0F 38 1D /r	SSSE3
PABSW xmm1, xmm2/m128	66 0F 38 1D /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn packssdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPackssdw<T, U>, 

PACKSSDW instruction

Instruction	Opcode	CPUID
PACKSSDW mm1, mm2/m64	NP 0F 6B /r	MMX
PACKSSDW xmm1, xmm2/m128	66 0F 6B /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn packsswb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPacksswb<T, U>, 

PACKSSWB instruction

Instruction	Opcode	CPUID
PACKSSWB mm1, mm2/m64	NP 0F 63 /r	MMX
PACKSSWB xmm1, xmm2/m128	66 0F 63 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn packusdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPackusdw<T, U>, 

PACKUSDW instruction

Instruction	Opcode	CPUID
PACKUSDW xmm1, xmm2/m128	66 0F 38 2B /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn packuswb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPackuswb<T, U>, 

PACKUSWB instruction

Instruction	Opcode	CPUID
PACKUSWB mm, mm/m64	NP 0F 67 /r	MMX
PACKUSWB xmm1, xmm2/m128	66 0F 67 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn paddb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaddb<T, U>, 

PADDB instruction

Instruction	Opcode	CPUID
PADDB mm, mm/m64	NP 0F FC /r	MMX
PADDB xmm1, xmm2/m128	66 0F FC /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn paddd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaddd<T, U>, 

PADDD instruction

Instruction	Opcode	CPUID
PADDD mm, mm/m64	NP 0F FE /r	MMX
PADDD xmm1, xmm2/m128	66 0F FE /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn paddq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaddq<T, U>, 

PADDQ instruction

Instruction	Opcode	CPUID
PADDQ mm, mm/m64	NP 0F D4 /r	MMX
PADDQ xmm1, xmm2/m128	66 0F D4 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn paddsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaddsb<T, U>, 

PADDSB instruction

Instruction	Opcode	CPUID
PADDSB mm, mm/m64	NP 0F EC /r	MMX
PADDSB xmm1, xmm2/m128	66 0F EC /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn paddsiw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaddsiw<T, U>, 

PADDSIW instruction

Instruction	Opcode	CPUID
PADDSIW mm, mm/m64	0F 51 /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn paddsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaddsw<T, U>, 

PADDSW instruction

Instruction	Opcode	CPUID
PADDSW mm, mm/m64	NP 0F ED /r	MMX
PADDSW xmm1, xmm2/m128	66 0F ED /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn paddusb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaddusb<T, U>, 

PADDUSB instruction

Instruction	Opcode	CPUID
PADDUSB mm, mm/m64	NP 0F DC /r	MMX
PADDUSB xmm1, xmm2/m128	66 0F DC /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn paddusw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaddusw<T, U>, 

PADDUSW instruction

Instruction	Opcode	CPUID
PADDUSW mm, mm/m64	NP 0F DD /r	MMX
PADDUSW xmm1, xmm2/m128	66 0F DD /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn paddw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaddw<T, U>, 

PADDW instruction

Instruction	Opcode	CPUID
PADDW mm, mm/m64	NP 0F FD /r	MMX
PADDW xmm1, xmm2/m128	66 0F FD /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn palignr<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPalignr<T, U, V>, 

PALIGNR instruction

Instruction	Opcode	CPUID
PALIGNR mm1, mm2/m64, imm8	NP 0F 3A 0F /r ib	SSSE3
PALIGNR xmm1, xmm2/m128, imm8	66 0F 3A 0F /r ib	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pand<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPand<T, U>, 

PAND instruction

Instruction	Opcode	CPUID
PAND mm, mm/m64	NP 0F DB /r	MMX
PAND xmm1, xmm2/m128	66 0F DB /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pandn<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPandn<T, U>, 

PANDN instruction

Instruction	Opcode	CPUID
PANDN mm, mm/m64	NP 0F DF /r	MMX
PANDN xmm1, xmm2/m128	66 0F DF /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pause(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPause, 

PAUSE instruction

Instruction	Opcode	CPUID
PAUSE	F3 90	Pentium 4 or later

Errors

Fails if an operand is invalid (basic checks only)

pub fn paveb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPaveb<T, U>, 

PAVEB instruction

Instruction	Opcode	CPUID
PAVEB mm, mm/m64	0F 50 /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pavgb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPavgb<T, U>, 

PAVGB instruction

Instruction	Opcode	CPUID
PAVGB mm1, mm2/m64	NP 0F E0 /r	SSE
PAVGB xmm1, xmm2/m128	66 0F E0 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pavgusb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPavgusb<T, U>, 

PAVGUSB instruction

Instruction	Opcode	CPUID
PAVGUSB mm, mm/m64	0F 0F /r BF	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pavgw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPavgw<T, U>, 

PAVGW instruction

Instruction	Opcode	CPUID
PAVGW mm1, mm2/m64	NP 0F E3 /r	SSE
PAVGW xmm1, xmm2/m128	66 0F E3 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pblendvb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPblendvb<T, U>, 

PBLENDVB instruction

Instruction	Opcode	CPUID
PBLENDVB xmm1, xmm2/m128, <XMM0>	66 0F 38 10 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pblendw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPblendw<T, U, V>, 

PBLENDW instruction

Instruction	Opcode	CPUID
PBLENDW xmm1, xmm2/m128, imm8	66 0F 3A 0E /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pclmulhqhqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPclmulhqhqdq<T, U>, 

PCLMULHQHQDQ instruction

Instruction	Opcode	CPUID
PCLMULQDQ xmm1, xmm2/m128, imm8	66 0F 3A 44 /r ib	PCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pclmulhqlqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPclmulhqlqdq<T, U>, 

PCLMULHQLQDQ instruction

Instruction	Opcode	CPUID
PCLMULQDQ xmm1, xmm2/m128, imm8	66 0F 3A 44 /r ib	PCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pclmullqhqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPclmullqhqdq<T, U>, 

PCLMULLQHQDQ instruction

Instruction	Opcode	CPUID
PCLMULQDQ xmm1, xmm2/m128, imm8	66 0F 3A 44 /r ib	PCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pclmullqlqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPclmullqlqdq<T, U>, 

PCLMULLQLQDQ instruction

Instruction	Opcode	CPUID
PCLMULQDQ xmm1, xmm2/m128, imm8	66 0F 3A 44 /r ib	PCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pclmulqdq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPclmulqdq<T, U, V>, 

PCLMULQDQ instruction

Instruction	Opcode	CPUID
PCLMULQDQ xmm1, xmm2/m128, imm8	66 0F 3A 44 /r ib	PCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pcmpeqb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPcmpeqb<T, U>, 

PCMPEQB instruction

Instruction	Opcode	CPUID
PCMPEQB mm, mm/m64	NP 0F 74 /r	MMX
PCMPEQB xmm1, xmm2/m128	66 0F 74 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pcmpeqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPcmpeqd<T, U>, 

PCMPEQD instruction

Instruction	Opcode	CPUID
PCMPEQD mm, mm/m64	NP 0F 76 /r	MMX
PCMPEQD xmm1, xmm2/m128	66 0F 76 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pcmpeqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPcmpeqq<T, U>, 

PCMPEQQ instruction

Instruction	Opcode	CPUID
PCMPEQQ xmm1, xmm2/m128	66 0F 38 29 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pcmpeqw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPcmpeqw<T, U>, 

PCMPEQW instruction

Instruction	Opcode	CPUID
PCMPEQW mm, mm/m64	NP 0F 75 /r	MMX
PCMPEQW xmm1, xmm2/m128	66 0F 75 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pcmpestri<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPcmpestri<T, U, V>, 

PCMPESTRI instruction

Instruction	Opcode	CPUID
PCMPESTRI xmm1, xmm2/m128, imm8	66 0F 3A 61 /r ib	SSE4.2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pcmpestri64<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPcmpestri64<T, U, V>, 

PCMPESTRI64 instruction

Instruction	Opcode	CPUID
PCMPESTRI64 xmm1, xmm2/m128, imm8	66 o64 0F 3A 61 /r ib	SSE4.2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pcmpestrm<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPcmpestrm<T, U, V>, 

PCMPESTRM instruction

Instruction	Opcode	CPUID
PCMPESTRM xmm1, xmm2/m128, imm8	66 0F 3A 60 /r ib	SSE4.2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pcmpestrm64<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPcmpestrm64<T, U, V>, 

PCMPESTRM64 instruction

Instruction	Opcode	CPUID
PCMPESTRM64 xmm1, xmm2/m128, imm8	66 o64 0F 3A 60 /r ib	SSE4.2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pcmpgtb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPcmpgtb<T, U>, 

PCMPGTB instruction

Instruction	Opcode	CPUID
PCMPGTB mm, mm/m64	NP 0F 64 /r	MMX
PCMPGTB xmm1, xmm2/m128	66 0F 64 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pcmpgtd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPcmpgtd<T, U>, 

PCMPGTD instruction

Instruction	Opcode	CPUID
PCMPGTD mm, mm/m64	NP 0F 66 /r	MMX
PCMPGTD xmm1, xmm2/m128	66 0F 66 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pcmpgtq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPcmpgtq<T, U>, 

PCMPGTQ instruction

Instruction	Opcode	CPUID
PCMPGTQ xmm1, xmm2/m128	66 0F 38 37 /r	SSE4.2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pcmpgtw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPcmpgtw<T, U>, 

PCMPGTW instruction

Instruction	Opcode	CPUID
PCMPGTW mm, mm/m64	NP 0F 65 /r	MMX
PCMPGTW xmm1, xmm2/m128	66 0F 65 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pcmpistri<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPcmpistri<T, U, V>, 

PCMPISTRI instruction

Instruction	Opcode	CPUID
PCMPISTRI xmm1, xmm2/m128, imm8	66 0F 3A 63 /r ib	SSE4.2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pcmpistrm<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPcmpistrm<T, U, V>, 

PCMPISTRM instruction

Instruction	Opcode	CPUID
PCMPISTRM xmm1, xmm2/m128, imm8	66 0F 3A 62 /r ib	SSE4.2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pcommit(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPcommit, 

PCOMMIT instruction

Instruction	Opcode	CPUID
PCOMMIT	66 0F AE F8	PCOMMIT

Errors

Fails if an operand is invalid (basic checks only)

pub fn pconfig(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPconfig, 

PCONFIG instruction

Instruction	Opcode	CPUID
PCONFIG	NP 0F 01 C5	PCONFIG

Errors

Fails if an operand is invalid (basic checks only)

pub fn pdep<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmPdep<T, U, V>, 

PDEP instruction

Instruction	Opcode	CPUID
PDEP r32a, r32b, r/m32	VEX.LZ.F2.0F38.W0 F5 /r	BMI2
PDEP r64a, r64b, r/m64	VEX.LZ.F2.0F38.W1 F5 /r	BMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pdistib<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPdistib<T, U>, 

PDISTIB instruction

Instruction	Opcode	CPUID
PDISTIB mm, m64	0F 54 /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pext<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmPext<T, U, V>, 

PEXT instruction

Instruction	Opcode	CPUID
PEXT r32a, r32b, r/m32	VEX.LZ.F3.0F38.W0 F5 /r	BMI2
PEXT r64a, r64b, r/m64	VEX.LZ.F3.0F38.W1 F5 /r	BMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pextrb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPextrb<T, U, V>, 

PEXTRB instruction

Instruction	Opcode	CPUID
PEXTRB r32/m8, xmm2, imm8	66 0F 3A 14 /r ib	SSE4.1
PEXTRB r64/m8, xmm2, imm8	66 o64 0F 3A 14 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pextrd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPextrd<T, U, V>, 

PEXTRD instruction

Instruction	Opcode	CPUID
PEXTRD r/m32, xmm2, imm8	66 0F 3A 16 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pextrq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPextrq<T, U, V>, 

PEXTRQ instruction

Instruction	Opcode	CPUID
PEXTRQ r/m64, xmm2, imm8	66 o64 0F 3A 16 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pextrw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPextrw<T, U, V>, 

PEXTRW instruction

Instruction	Opcode	CPUID
PEXTRW r32, mm, imm8	NP 0F C5 /r ib	SSE
PEXTRW r64, mm, imm8	NP o64 0F C5 /r ib	SSE
PEXTRW r32, xmm, imm8	66 0F C5 /r ib	SSE2
PEXTRW r64, xmm, imm8	66 o64 0F C5 /r ib	SSE2
PEXTRW r32/m16, xmm, imm8	66 0F 3A 15 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pf2id<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPf2id<T, U>, 

PF2ID instruction

Instruction	Opcode	CPUID
PF2ID mm, mm/m64	0F 0F /r 1D	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pf2iw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPf2iw<T, U>, 

PF2IW instruction

Instruction	Opcode	CPUID
PF2IW mm, mm/m64	0F 0F /r 1C	3DNOWEXT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfacc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfacc<T, U>, 

PFACC instruction

Instruction	Opcode	CPUID
PFACC mm, mm/m64	0F 0F /r AE	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfadd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfadd<T, U>, 

PFADD instruction

Instruction	Opcode	CPUID
PFADD mm, mm/m64	0F 0F /r 9E	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfcmpeq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfcmpeq<T, U>, 

PFCMPEQ instruction

Instruction	Opcode	CPUID
PFCMPEQ mm, mm/m64	0F 0F /r B0	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfcmpge<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfcmpge<T, U>, 

PFCMPGE instruction

Instruction	Opcode	CPUID
PFCMPGE mm, mm/m64	0F 0F /r 90	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfcmpgt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfcmpgt<T, U>, 

PFCMPGT instruction

Instruction	Opcode	CPUID
PFCMPGT mm, mm/m64	0F 0F /r A0	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfmax<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfmax<T, U>, 

PFMAX instruction

Instruction	Opcode	CPUID
PFMAX mm, mm/m64	0F 0F /r A4	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfmin<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfmin<T, U>, 

PFMIN instruction

Instruction	Opcode	CPUID
PFMIN mm, mm/m64	0F 0F /r 94	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfmul<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfmul<T, U>, 

PFMUL instruction

Instruction	Opcode	CPUID
PFMUL mm, mm/m64	0F 0F /r B4	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfnacc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfnacc<T, U>, 

PFNACC instruction

Instruction	Opcode	CPUID
PFNACC mm, mm/m64	0F 0F /r 8A	3DNOWEXT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfpnacc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfpnacc<T, U>, 

PFPNACC instruction

Instruction	Opcode	CPUID
PFPNACC mm, mm/m64	0F 0F /r 8E	3DNOWEXT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfrcp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfrcp<T, U>, 

PFRCP instruction

Instruction	Opcode	CPUID
PFRCP mm, mm/m64	0F 0F /r 96	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfrcpit1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfrcpit1<T, U>, 

PFRCPIT1 instruction

Instruction	Opcode	CPUID
PFRCPIT1 mm, mm/m64	0F 0F /r A6	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfrcpit2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfrcpit2<T, U>, 

PFRCPIT2 instruction

Instruction	Opcode	CPUID
PFRCPIT2 mm, mm/m64	0F 0F /r B6	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfrcpv<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfrcpv<T, U>, 

PFRCPV instruction

Instruction	Opcode	CPUID
PFRCPV mm, mm/m64	0F 0F /r 86	AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfrsqit1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfrsqit1<T, U>, 

PFRSQIT1 instruction

Instruction	Opcode	CPUID
PFRSQIT1 mm, mm/m64	0F 0F /r A7	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfrsqrt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfrsqrt<T, U>, 

PFRSQRT instruction

Instruction	Opcode	CPUID
PFRSQRT mm, mm/m64	0F 0F /r 97	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfrsqrtv<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfrsqrtv<T, U>, 

PFRSQRTV instruction

Instruction	Opcode	CPUID
PFRSQRTV mm, mm/m64	0F 0F /r 87	AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfsub<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfsub<T, U>, 

PFSUB instruction

Instruction	Opcode	CPUID
PFSUB mm, mm/m64	0F 0F /r 9A	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pfsubr<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPfsubr<T, U>, 

PFSUBR instruction

Instruction	Opcode	CPUID
PFSUBR mm, mm/m64	0F 0F /r AA	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn phaddd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPhaddd<T, U>, 

PHADDD instruction

Instruction	Opcode	CPUID
PHADDD mm1, mm2/m64	NP 0F 38 02 /r	SSSE3
PHADDD xmm1, xmm2/m128	66 0F 38 02 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn phaddsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPhaddsw<T, U>, 

PHADDSW instruction

Instruction	Opcode	CPUID
PHADDSW mm1, mm2/m64	NP 0F 38 03 /r	SSSE3
PHADDSW xmm1, xmm2/m128	66 0F 38 03 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn phaddw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPhaddw<T, U>, 

PHADDW instruction

Instruction	Opcode	CPUID
PHADDW mm1, mm2/m64	NP 0F 38 01 /r	SSSE3
PHADDW xmm1, xmm2/m128	66 0F 38 01 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn phminposuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPhminposuw<T, U>, 

PHMINPOSUW instruction

Instruction	Opcode	CPUID
PHMINPOSUW xmm1, xmm2/m128	66 0F 38 41 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn phsubd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPhsubd<T, U>, 

PHSUBD instruction

Instruction	Opcode	CPUID
PHSUBD mm1, mm2/m64	NP 0F 38 06 /r	SSSE3
PHSUBD xmm1, xmm2/m128	66 0F 38 06 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn phsubsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPhsubsw<T, U>, 

PHSUBSW instruction

Instruction	Opcode	CPUID
PHSUBSW mm1, mm2/m64	NP 0F 38 07 /r	SSSE3
PHSUBSW xmm1, xmm2/m128	66 0F 38 07 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn phsubw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPhsubw<T, U>, 

PHSUBW instruction

Instruction	Opcode	CPUID
PHSUBW mm1, mm2/m64	NP 0F 38 05 /r	SSSE3
PHSUBW xmm1, xmm2/m128	66 0F 38 05 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pi2fd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPi2fd<T, U>, 

PI2FD instruction

Instruction	Opcode	CPUID
PI2FD mm, mm/m64	0F 0F /r 0D	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pi2fw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPi2fw<T, U>, 

PI2FW instruction

Instruction	Opcode	CPUID
PI2FW mm, mm/m64	0F 0F /r 0C	3DNOWEXT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pinsrb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPinsrb<T, U, V>, 

PINSRB instruction

Instruction	Opcode	CPUID
PINSRB xmm1, r32/m8, imm8	66 0F 3A 20 /r ib	SSE4.1
PINSRB xmm1, r64/m8, imm8	66 o64 0F 3A 20 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pinsrd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPinsrd<T, U, V>, 

PINSRD instruction

Instruction	Opcode	CPUID
PINSRD xmm1, r/m32, imm8	66 0F 3A 22 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pinsrq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPinsrq<T, U, V>, 

PINSRQ instruction

Instruction	Opcode	CPUID
PINSRQ xmm1, r/m64, imm8	66 o64 0F 3A 22 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pinsrw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPinsrw<T, U, V>, 

PINSRW instruction

Instruction	Opcode	CPUID
PINSRW mm, r32/m16, imm8	NP 0F C4 /r ib	SSE
PINSRW mm, r64/m16, imm8	NP o64 0F C4 /r ib	SSE
PINSRW xmm, r32/m16, imm8	66 0F C4 /r ib	SSE2
PINSRW xmm, r64/m16, imm8	66 o64 0F C4 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pmachriw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmachriw<T, U>, 

PMACHRIW instruction

Instruction	Opcode	CPUID
PMACHRIW mm, m64	0F 5E /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmaddubsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmaddubsw<T, U>, 

PMADDUBSW instruction

Instruction	Opcode	CPUID
PMADDUBSW mm1, mm2/m64	NP 0F 38 04 /r	SSSE3
PMADDUBSW xmm1, xmm2/m128	66 0F 38 04 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmaddwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmaddwd<T, U>, 

PMADDWD instruction

Instruction	Opcode	CPUID
PMADDWD mm, mm/m64	NP 0F F5 /r	MMX
PMADDWD xmm1, xmm2/m128	66 0F F5 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmagw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmagw<T, U>, 

PMAGW instruction

Instruction	Opcode	CPUID
PMAGW mm, mm/m64	0F 52 /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmaxsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmaxsb<T, U>, 

PMAXSB instruction

Instruction	Opcode	CPUID
PMAXSB xmm1, xmm2/m128	66 0F 38 3C /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmaxsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmaxsd<T, U>, 

PMAXSD instruction

Instruction	Opcode	CPUID
PMAXSD xmm1, xmm2/m128	66 0F 38 3D /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmaxsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmaxsw<T, U>, 

PMAXSW instruction

Instruction	Opcode	CPUID
PMAXSW mm1, mm2/m64	NP 0F EE /r	SSE
PMAXSW xmm1, xmm2/m128	66 0F EE /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmaxub<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmaxub<T, U>, 

PMAXUB instruction

Instruction	Opcode	CPUID
PMAXUB mm1, mm2/m64	NP 0F DE /r	SSE
PMAXUB xmm1, xmm2/m128	66 0F DE /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmaxud<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmaxud<T, U>, 

PMAXUD instruction

Instruction	Opcode	CPUID
PMAXUD xmm1, xmm2/m128	66 0F 38 3F /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmaxuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmaxuw<T, U>, 

PMAXUW instruction

Instruction	Opcode	CPUID
PMAXUW xmm1, xmm2/m128	66 0F 38 3E /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pminsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPminsb<T, U>, 

PMINSB instruction

Instruction	Opcode	CPUID
PMINSB xmm1, xmm2/m128	66 0F 38 38 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pminsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPminsd<T, U>, 

PMINSD instruction

Instruction	Opcode	CPUID
PMINSD xmm1, xmm2/m128	66 0F 38 39 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pminsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPminsw<T, U>, 

PMINSW instruction

Instruction	Opcode	CPUID
PMINSW mm1, mm2/m64	NP 0F EA /r	SSE
PMINSW xmm1, xmm2/m128	66 0F EA /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pminub<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPminub<T, U>, 

PMINUB instruction

Instruction	Opcode	CPUID
PMINUB mm1, mm2/m64	NP 0F DA /r	SSE
PMINUB xmm1, xmm2/m128	66 0F DA /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pminud<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPminud<T, U>, 

PMINUD instruction

Instruction	Opcode	CPUID
PMINUD xmm1, xmm2/m128	66 0F 38 3B /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pminuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPminuw<T, U>, 

PMINUW instruction

Instruction	Opcode	CPUID
PMINUW xmm1, xmm2/m128	66 0F 38 3A /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovmskb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovmskb<T, U>, 

PMOVMSKB instruction

Instruction	Opcode	CPUID
PMOVMSKB r32, mm	NP 0F D7 /r	SSE
PMOVMSKB r64, mm	NP o64 0F D7 /r	SSE
PMOVMSKB r32, xmm	66 0F D7 /r	SSE2
PMOVMSKB r64, xmm	66 o64 0F D7 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovsxbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovsxbd<T, U>, 

PMOVSXBD instruction

Instruction	Opcode	CPUID
PMOVSXBD xmm1, xmm2/m32	66 0F 38 21 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovsxbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovsxbq<T, U>, 

PMOVSXBQ instruction

Instruction	Opcode	CPUID
PMOVSXBQ xmm1, xmm2/m16	66 0F 38 22 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovsxbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovsxbw<T, U>, 

PMOVSXBW instruction

Instruction	Opcode	CPUID
PMOVSXBW xmm1, xmm2/m64	66 0F 38 20 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovsxdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovsxdq<T, U>, 

PMOVSXDQ instruction

Instruction	Opcode	CPUID
PMOVSXDQ xmm1, xmm2/m64	66 0F 38 25 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovsxwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovsxwd<T, U>, 

PMOVSXWD instruction

Instruction	Opcode	CPUID
PMOVSXWD xmm1, xmm2/m64	66 0F 38 23 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovsxwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovsxwq<T, U>, 

PMOVSXWQ instruction

Instruction	Opcode	CPUID
PMOVSXWQ xmm1, xmm2/m32	66 0F 38 24 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovzxbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovzxbd<T, U>, 

PMOVZXBD instruction

Instruction	Opcode	CPUID
PMOVZXBD xmm1, xmm2/m32	66 0F 38 31 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovzxbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovzxbq<T, U>, 

PMOVZXBQ instruction

Instruction	Opcode	CPUID
PMOVZXBQ xmm1, xmm2/m16	66 0F 38 32 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovzxbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovzxbw<T, U>, 

PMOVZXBW instruction

Instruction	Opcode	CPUID
PMOVZXBW xmm1, xmm2/m64	66 0F 38 30 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovzxdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovzxdq<T, U>, 

PMOVZXDQ instruction

Instruction	Opcode	CPUID
PMOVZXDQ xmm1, xmm2/m64	66 0F 38 35 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovzxwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovzxwd<T, U>, 

PMOVZXWD instruction

Instruction	Opcode	CPUID
PMOVZXWD xmm1, xmm2/m64	66 0F 38 33 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmovzxwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmovzxwq<T, U>, 

PMOVZXWQ instruction

Instruction	Opcode	CPUID
PMOVZXWQ xmm1, xmm2/m32	66 0F 38 34 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmuldq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmuldq<T, U>, 

PMULDQ instruction

Instruction	Opcode	CPUID
PMULDQ xmm1, xmm2/m128	66 0F 38 28 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmulhriw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmulhriw<T, U>, 

PMULHRIW instruction

Instruction	Opcode	CPUID
PMULHRIW mm, mm/m64	0F 5D /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmulhrsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmulhrsw<T, U>, 

PMULHRSW instruction

Instruction	Opcode	CPUID
PMULHRSW mm1, mm2/m64	NP 0F 38 0B /r	SSSE3
PMULHRSW xmm1, xmm2/m128	66 0F 38 0B /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmulhrw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmulhrw<T, U>, 

PMULHRW instruction

Instruction	Opcode	CPUID
PMULHRW mm, mm/m64	0F 0F /r B7	3DNOW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmulhrw_cyrix<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmulhrw_cyrix<T, U>, 

PMULHRW_CYRIX instruction

Instruction	Opcode	CPUID
PMULHRW mm, mm/m64	0F 59 /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmulhuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmulhuw<T, U>, 

PMULHUW instruction

Instruction	Opcode	CPUID
PMULHUW mm1, mm2/m64	NP 0F E4 /r	SSE
PMULHUW xmm1, xmm2/m128	66 0F E4 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmulhw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmulhw<T, U>, 

PMULHW instruction

Instruction	Opcode	CPUID
PMULHW mm, mm/m64	NP 0F E5 /r	MMX
PMULHW xmm1, xmm2/m128	66 0F E5 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmulld<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmulld<T, U>, 

PMULLD instruction

Instruction	Opcode	CPUID
PMULLD xmm1, xmm2/m128	66 0F 38 40 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmullw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmullw<T, U>, 

PMULLW instruction

Instruction	Opcode	CPUID
PMULLW mm, mm/m64	NP 0F D5 /r	MMX
PMULLW xmm1, xmm2/m128	66 0F D5 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmuludq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmuludq<T, U>, 

PMULUDQ instruction

Instruction	Opcode	CPUID
PMULUDQ mm1, mm2/m64	NP 0F F4 /r	SSE2
PMULUDQ xmm1, xmm2/m128	66 0F F4 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmvgezb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmvgezb<T, U>, 

PMVGEZB instruction

Instruction	Opcode	CPUID
PMVGEZB mm, m64	0F 5C /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmvlzb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmvlzb<T, U>, 

PMVLZB instruction

Instruction	Opcode	CPUID
PMVLZB mm, m64	0F 5B /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmvnzb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmvnzb<T, U>, 

PMVNZB instruction

Instruction	Opcode	CPUID
PMVNZB mm, m64	0F 5A /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pmvzb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPmvzb<T, U>, 

PMVZB instruction

Instruction	Opcode	CPUID
PMVZB mm, m64	0F 58 /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pop<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPop<T>, 

POP instruction

Instruction	Opcode	CPUID
POP ES	o16 07	8086+
POP ES	o32 07	386+
POP SS	o16 17	8086+
POP SS	o32 17	386+
POP DS	o16 1F	8086+
POP DS	o32 1F	386+
POP r16	o16 58+rw	8086+
POP r32	o32 58+rd	386+
POP r64	o64 58+ro	X64
POP r/m16	o16 8F /0	8086+
POP r/m32	o32 8F /0	386+
POP r/m64	o64 8F /0	X64
POP FS	o16 0F A1	386+
POP FS	o32 0F A1	386+
POP FS	o64 0F A1	X64
POP GS	o16 0F A9	386+
POP GS	o32 0F A9	386+
POP GS	o64 0F A9	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn popa(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPopa, 

POPA instruction

Instruction	Opcode	CPUID
POPA	o16 61	186+

Errors

Fails if an operand is invalid (basic checks only)

pub fn popad(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPopad, 

POPAD instruction

Instruction	Opcode	CPUID
POPAD	o32 61	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn popcnt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPopcnt<T, U>, 

POPCNT instruction

Instruction	Opcode	CPUID
POPCNT r16, r/m16	o16 F3 0F B8 /r	POPCNT
POPCNT r32, r/m32	o32 F3 0F B8 /r	POPCNT
POPCNT r64, r/m64	F3 o64 0F B8 /r	POPCNT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn popf(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPopf, 

POPF instruction

Instruction	Opcode	CPUID
POPF	o16 9D	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn popfd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPopfd, 

POPFD instruction

Instruction	Opcode	CPUID
POPFD	o32 9D	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn popfq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPopfq, 

POPFQ instruction

Instruction	Opcode	CPUID
POPFQ	o64 9D	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn por<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPor<T, U>, 

POR instruction

Instruction	Opcode	CPUID
POR mm, mm/m64	NP 0F EB /r	MMX
POR xmm1, xmm2/m128	66 0F EB /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn prefetch<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPrefetch<T>, 

PREFETCH instruction

Instruction	Opcode	CPUID
PREFETCH m8	0F 0D /0	PREFETCHW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn prefetchnta<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPrefetchnta<T>, 

PREFETCHNTA instruction

Instruction	Opcode	CPUID
PREFETCHNTA m8	0F 18 /0	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn prefetcht0<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPrefetcht0<T>, 

PREFETCHT0 instruction

Instruction	Opcode	CPUID
PREFETCHT0 m8	0F 18 /1	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn prefetcht1<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPrefetcht1<T>, 

PREFETCHT1 instruction

Instruction	Opcode	CPUID
PREFETCHT1 m8	0F 18 /2	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn prefetcht2<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPrefetcht2<T>, 

PREFETCHT2 instruction

Instruction	Opcode	CPUID
PREFETCHT2 m8	0F 18 /3	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn prefetchw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPrefetchw<T>, 

PREFETCHW instruction

Instruction	Opcode	CPUID
PREFETCHW m8	0F 0D /1	PREFETCHW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn prefetchwt1<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPrefetchwt1<T>, 

PREFETCHWT1 instruction

Instruction	Opcode	CPUID
PREFETCHWT1 m8	0F 0D /2	PREFETCHWT1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn psadbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsadbw<T, U>, 

PSADBW instruction

Instruction	Opcode	CPUID
PSADBW mm1, mm2/m64	NP 0F F6 /r	SSE
PSADBW xmm1, xmm2/m128	66 0F F6 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pshufb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPshufb<T, U>, 

PSHUFB instruction

Instruction	Opcode	CPUID
PSHUFB mm1, mm2/m64	NP 0F 38 00 /r	SSSE3
PSHUFB xmm1, xmm2/m128	66 0F 38 00 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pshufd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPshufd<T, U, V>, 

PSHUFD instruction

Instruction	Opcode	CPUID
PSHUFD xmm1, xmm2/m128, imm8	66 0F 70 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pshufhw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPshufhw<T, U, V>, 

PSHUFHW instruction

Instruction	Opcode	CPUID
PSHUFHW xmm1, xmm2/m128, imm8	F3 0F 70 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pshuflw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPshuflw<T, U, V>, 

PSHUFLW instruction

Instruction	Opcode	CPUID
PSHUFLW xmm1, xmm2/m128, imm8	F2 0F 70 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn pshufw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmPshufw<T, U, V>, 

PSHUFW instruction

Instruction	Opcode	CPUID
PSHUFW mm1, mm2/m64, imm8	NP 0F 70 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn psignb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsignb<T, U>, 

PSIGNB instruction

Instruction	Opcode	CPUID
PSIGNB mm1, mm2/m64	NP 0F 38 08 /r	SSSE3
PSIGNB xmm1, xmm2/m128	66 0F 38 08 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psignd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsignd<T, U>, 

PSIGND instruction

Instruction	Opcode	CPUID
PSIGND mm1, mm2/m64	NP 0F 38 0A /r	SSSE3
PSIGND xmm1, xmm2/m128	66 0F 38 0A /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psignw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsignw<T, U>, 

PSIGNW instruction

Instruction	Opcode	CPUID
PSIGNW mm1, mm2/m64	NP 0F 38 09 /r	SSSE3
PSIGNW xmm1, xmm2/m128	66 0F 38 09 /r	SSSE3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pslld<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPslld<T, U>, 

PSLLD instruction

Instruction	Opcode	CPUID
PSLLD mm, imm8	NP 0F 72 /6 ib	MMX
PSLLD xmm1, imm8	66 0F 72 /6 ib	SSE2
PSLLD mm, mm/m64	NP 0F F2 /r	MMX
PSLLD xmm1, xmm2/m128	66 0F F2 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pslldq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPslldq<T, U>, 

PSLLDQ instruction

Instruction	Opcode	CPUID
PSLLDQ xmm1, imm8	66 0F 73 /7 ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psllq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsllq<T, U>, 

PSLLQ instruction

Instruction	Opcode	CPUID
PSLLQ mm, imm8	NP 0F 73 /6 ib	MMX
PSLLQ xmm1, imm8	66 0F 73 /6 ib	SSE2
PSLLQ mm, mm/m64	NP 0F F3 /r	MMX
PSLLQ xmm1, xmm2/m128	66 0F F3 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psllw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsllw<T, U>, 

PSLLW instruction

Instruction	Opcode	CPUID
PSLLW mm1, imm8	NP 0F 71 /6 ib	MMX
PSLLW xmm1, imm8	66 0F 71 /6 ib	SSE2
PSLLW mm, mm/m64	NP 0F F1 /r	MMX
PSLLW xmm1, xmm2/m128	66 0F F1 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psmash(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPsmash, 

PSMASH instruction

Instruction	Opcode	CPUID
PSMASH	F3 0F 01 FF	SEV-SNP

Errors

Fails if an operand is invalid (basic checks only)

pub fn psrad<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsrad<T, U>, 

PSRAD instruction

Instruction	Opcode	CPUID
PSRAD mm, imm8	NP 0F 72 /4 ib	MMX
PSRAD xmm1, imm8	66 0F 72 /4 ib	SSE2
PSRAD mm, mm/m64	NP 0F E2 /r	MMX
PSRAD xmm1, xmm2/m128	66 0F E2 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psraw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsraw<T, U>, 

PSRAW instruction

Instruction	Opcode	CPUID
PSRAW mm, imm8	NP 0F 71 /4 ib	MMX
PSRAW xmm1, imm8	66 0F 71 /4 ib	SSE2
PSRAW mm, mm/m64	NP 0F E1 /r	MMX
PSRAW xmm1, xmm2/m128	66 0F E1 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psrld<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsrld<T, U>, 

PSRLD instruction

Instruction	Opcode	CPUID
PSRLD mm, imm8	NP 0F 72 /2 ib	MMX
PSRLD xmm1, imm8	66 0F 72 /2 ib	SSE2
PSRLD mm, mm/m64	NP 0F D2 /r	MMX
PSRLD xmm1, xmm2/m128	66 0F D2 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psrldq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsrldq<T, U>, 

PSRLDQ instruction

Instruction	Opcode	CPUID
PSRLDQ xmm1, imm8	66 0F 73 /3 ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psrlq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsrlq<T, U>, 

PSRLQ instruction

Instruction	Opcode	CPUID
PSRLQ mm, imm8	NP 0F 73 /2 ib	MMX
PSRLQ xmm1, imm8	66 0F 73 /2 ib	SSE2
PSRLQ mm, mm/m64	NP 0F D3 /r	MMX
PSRLQ xmm1, xmm2/m128	66 0F D3 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psrlw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsrlw<T, U>, 

PSRLW instruction

Instruction	Opcode	CPUID
PSRLW mm, imm8	NP 0F 71 /2 ib	MMX
PSRLW xmm1, imm8	66 0F 71 /2 ib	SSE2
PSRLW mm, mm/m64	NP 0F D1 /r	MMX
PSRLW xmm1, xmm2/m128	66 0F D1 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psubb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsubb<T, U>, 

PSUBB instruction

Instruction	Opcode	CPUID
PSUBB mm, mm/m64	NP 0F F8 /r	MMX
PSUBB xmm1, xmm2/m128	66 0F F8 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psubd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsubd<T, U>, 

PSUBD instruction

Instruction	Opcode	CPUID
PSUBD mm, mm/m64	NP 0F FA /r	MMX
PSUBD xmm1, xmm2/m128	66 0F FA /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psubq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsubq<T, U>, 

PSUBQ instruction

Instruction	Opcode	CPUID
PSUBQ mm1, mm2/m64	NP 0F FB /r	SSE2
PSUBQ xmm1, xmm2/m128	66 0F FB /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psubsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsubsb<T, U>, 

PSUBSB instruction

Instruction	Opcode	CPUID
PSUBSB mm, mm/m64	NP 0F E8 /r	MMX
PSUBSB xmm1, xmm2/m128	66 0F E8 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psubsiw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsubsiw<T, U>, 

PSUBSIW instruction

Instruction	Opcode	CPUID
PSUBSIW mm, mm/m64	0F 55 /r	CYRIX_EMMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psubsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsubsw<T, U>, 

PSUBSW instruction

Instruction	Opcode	CPUID
PSUBSW mm, mm/m64	NP 0F E9 /r	MMX
PSUBSW xmm1, xmm2/m128	66 0F E9 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psubusb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsubusb<T, U>, 

PSUBUSB instruction

Instruction	Opcode	CPUID
PSUBUSB mm, mm/m64	NP 0F D8 /r	MMX
PSUBUSB xmm1, xmm2/m128	66 0F D8 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psubusw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsubusw<T, U>, 

PSUBUSW instruction

Instruction	Opcode	CPUID
PSUBUSW mm, mm/m64	NP 0F D9 /r	MMX
PSUBUSW xmm1, xmm2/m128	66 0F D9 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn psubw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPsubw<T, U>, 

PSUBW instruction

Instruction	Opcode	CPUID
PSUBW mm, mm/m64	NP 0F F9 /r	MMX
PSUBW xmm1, xmm2/m128	66 0F F9 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn pswapd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPswapd<T, U>, 

PSWAPD instruction

Instruction	Opcode	CPUID
PSWAPD mm, mm/m64	0F 0F /r BB	3DNOWEXT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ptest<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPtest<T, U>, 

PTEST instruction

Instruction	Opcode	CPUID
PTEST xmm1, xmm2/m128	66 0F 38 17 /r	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ptwrite<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPtwrite<T>, 

PTWRITE instruction

Instruction	Opcode	CPUID
PTWRITE r/m32	F3 0F AE /4	PTWRITE
PTWRITE r/m64	F3 o64 0F AE /4	PTWRITE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn punpckhbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPunpckhbw<T, U>, 

PUNPCKHBW instruction

Instruction	Opcode	CPUID
PUNPCKHBW mm, mm/m64	NP 0F 68 /r	MMX
PUNPCKHBW xmm1, xmm2/m128	66 0F 68 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn punpckhdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPunpckhdq<T, U>, 

PUNPCKHDQ instruction

Instruction	Opcode	CPUID
PUNPCKHDQ mm, mm/m64	NP 0F 6A /r	MMX
PUNPCKHDQ xmm1, xmm2/m128	66 0F 6A /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn punpckhqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPunpckhqdq<T, U>, 

PUNPCKHQDQ instruction

Instruction	Opcode	CPUID
PUNPCKHQDQ xmm1, xmm2/m128	66 0F 6D /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn punpckhwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPunpckhwd<T, U>, 

PUNPCKHWD instruction

Instruction	Opcode	CPUID
PUNPCKHWD mm, mm/m64	NP 0F 69 /r	MMX
PUNPCKHWD xmm1, xmm2/m128	66 0F 69 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn punpcklbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPunpcklbw<T, U>, 

PUNPCKLBW instruction

Instruction	Opcode	CPUID
PUNPCKLBW mm, mm/m32	NP 0F 60 /r	MMX
PUNPCKLBW xmm1, xmm2/m128	66 0F 60 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn punpckldq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPunpckldq<T, U>, 

PUNPCKLDQ instruction

Instruction	Opcode	CPUID
PUNPCKLDQ mm, mm/m32	NP 0F 62 /r	MMX
PUNPCKLDQ xmm1, xmm2/m128	66 0F 62 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn punpcklqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPunpcklqdq<T, U>, 

PUNPCKLQDQ instruction

Instruction	Opcode	CPUID
PUNPCKLQDQ xmm1, xmm2/m128	66 0F 6C /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn punpcklwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPunpcklwd<T, U>, 

PUNPCKLWD instruction

Instruction	Opcode	CPUID
PUNPCKLWD mm, mm/m32	NP 0F 61 /r	MMX
PUNPCKLWD xmm1, xmm2/m128	66 0F 61 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn push<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmPush<T>, 

PUSH instruction

Instruction	Opcode	CPUID
PUSH ES	o16 06	8086+
PUSH ES	o32 06	386+
PUSH CS	o16 0E	8086+
PUSH CS	o32 0E	386+
PUSH SS	o16 16	8086+
PUSH SS	o32 16	386+
PUSH DS	o16 1E	8086+
PUSH DS	o32 1E	386+
PUSH r16	o16 50+rw	8086+
PUSH r32	o32 50+rd	386+
PUSH r64	o64 50+ro	X64
PUSH imm16	o16 68 iw	186+
PUSH imm32	o32 68 id	386+
PUSH imm32	o64 68 id	X64
PUSH imm8	o16 6A ib	186+
PUSH imm8	o32 6A ib	386+
PUSH imm8	o64 6A ib	X64
PUSH r/m16	o16 FF /6	8086+
PUSH r/m32	o32 FF /6	386+
PUSH r/m64	o64 FF /6	X64
PUSH FS	o16 0F A0	386+
PUSH FS	o32 0F A0	386+
PUSH FS	o64 0F A0	X64
PUSH GS	o16 0F A8	386+
PUSH GS	o32 0F A8	386+
PUSH GS	o64 0F A8	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn pusha(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPusha, 

PUSHA instruction

Instruction	Opcode	CPUID
PUSHA	o16 60	186+

Errors

Fails if an operand is invalid (basic checks only)

pub fn pushad(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPushad, 

PUSHAD instruction

Instruction	Opcode	CPUID
PUSHAD	o32 60	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn pushf(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPushf, 

PUSHF instruction

Instruction	Opcode	CPUID
PUSHF	o16 9C	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn pushfd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPushfd, 

PUSHFD instruction

Instruction	Opcode	CPUID
PUSHFD	o32 9C	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn pushfq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPushfq, 

PUSHFQ instruction

Instruction	Opcode	CPUID
PUSHFQ	o64 9C	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn pvalidate(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmPvalidate, 

PVALIDATE instruction

Instruction	Opcode	CPUID
PVALIDATE	a16 F2 0F 01 FF	SEV-SNP
PVALIDATE	a32 F2 0F 01 FF	SEV-SNP
PVALIDATE	a64 F2 0F 01 FF	SEV-SNP

Errors

Fails if an operand is invalid (basic checks only)

pub fn pxor<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmPxor<T, U>, 

PXOR instruction

Instruction	Opcode	CPUID
PXOR mm, mm/m64	NP 0F EF /r	MMX
PXOR xmm1, xmm2/m128	66 0F EF /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn rcl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmRcl<T, U>, 

RCL instruction

Instruction	Opcode	CPUID
RCL r/m8, imm8	C0 /2 ib	186+
RCL r/m16, imm8	o16 C1 /2 ib	186+
RCL r/m32, imm8	o32 C1 /2 ib	386+
RCL r/m64, imm8	o64 C1 /2 ib	X64
RCL r/m8, 1	D0 /2	8086+
RCL r/m16, 1	o16 D1 /2	8086+
RCL r/m32, 1	o32 D1 /2	386+
RCL r/m64, 1	o64 D1 /2	X64
RCL r/m8, CL	D2 /2	8086+
RCL r/m16, CL	o16 D3 /2	8086+
RCL r/m32, CL	o32 D3 /2	386+
RCL r/m64, CL	o64 D3 /2	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn rcpps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmRcpps<T, U>, 

RCPPS instruction

Instruction	Opcode	CPUID
RCPPS xmm1, xmm2/m128	NP 0F 53 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn rcpss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmRcpss<T, U>, 

RCPSS instruction

Instruction	Opcode	CPUID
RCPSS xmm1, xmm2/m32	F3 0F 53 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn rcr<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmRcr<T, U>, 

RCR instruction

Instruction	Opcode	CPUID
RCR r/m8, imm8	C0 /3 ib	186+
RCR r/m16, imm8	o16 C1 /3 ib	186+
RCR r/m32, imm8	o32 C1 /3 ib	386+
RCR r/m64, imm8	o64 C1 /3 ib	X64
RCR r/m8, 1	D0 /3	8086+
RCR r/m16, 1	o16 D1 /3	8086+
RCR r/m32, 1	o32 D1 /3	386+
RCR r/m64, 1	o64 D1 /3	X64
RCR r/m8, CL	D2 /3	8086+
RCR r/m16, CL	o16 D3 /3	8086+
RCR r/m32, CL	o32 D3 /3	386+
RCR r/m64, CL	o64 D3 /3	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn rdfsbase<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRdfsbase<T>, 

RDFSBASE instruction

Instruction	Opcode	CPUID
RDFSBASE r32	F3 0F AE /0	FSGSBASE
RDFSBASE r64	F3 o64 0F AE /0	FSGSBASE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rdgsbase<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRdgsbase<T>, 

RDGSBASE instruction

Instruction	Opcode	CPUID
RDGSBASE r32	F3 0F AE /1	FSGSBASE
RDGSBASE r64	F3 o64 0F AE /1	FSGSBASE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rdm(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRdm, 

RDM instruction

Instruction	Opcode	CPUID
RDM	0F 3A	AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

pub fn rdmsr(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRdmsr, 

RDMSR instruction

Instruction	Opcode	CPUID
RDMSR	0F 32	MSR

Errors

Fails if an operand is invalid (basic checks only)

pub fn rdpid<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRdpid<T>, 

RDPID instruction

Instruction	Opcode	CPUID
RDPID r32	F3 0F C7 /7	RDPID
RDPID r64	F3 0F C7 /7	RDPID

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rdpkru(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRdpkru, 

RDPKRU instruction

Instruction	Opcode	CPUID
RDPKRU	NP 0F 01 EE	PKU

Errors

Fails if an operand is invalid (basic checks only)

pub fn rdpmc(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRdpmc, 

RDPMC instruction

Instruction	Opcode	CPUID
RDPMC	0F 33	Pentium MMX or later, or Pentium Pro or later

Errors

Fails if an operand is invalid (basic checks only)

pub fn rdpru(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRdpru, 

RDPRU instruction

Instruction	Opcode	CPUID
RDPRU	0F 01 FD	RDPRU

Errors

Fails if an operand is invalid (basic checks only)

pub fn rdrand<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRdrand<T>, 

RDRAND instruction

Instruction	Opcode	CPUID
RDRAND r16	o16 0F C7 /6	RDRAND
RDRAND r32	o32 0F C7 /6	RDRAND
RDRAND r64	o64 0F C7 /6	RDRAND

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rdseed<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRdseed<T>, 

RDSEED instruction

Instruction	Opcode	CPUID
RDSEED r16	o16 0F C7 /7	RDSEED
RDSEED r32	o32 0F C7 /7	RDSEED
RDSEED r64	o64 0F C7 /7	RDSEED

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rdshr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRdshr<T>, 

RDSHR instruction

Instruction	Opcode	CPUID
RDSHR r/m32	0F 36 /0	Cyrix 6x86MX, M II, III

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rdsspd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRdsspd<T>, 

RDSSPD instruction

Instruction	Opcode	CPUID
RDSSPD r32	F3 0F 1E /1	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rdsspq<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRdsspq<T>, 

RDSSPQ instruction

Instruction	Opcode	CPUID
RDSSPQ r64	F3 o64 0F 1E /1	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rdtsc(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRdtsc, 

RDTSC instruction

Instruction	Opcode	CPUID
RDTSC	0F 31	TSC

Errors

Fails if an operand is invalid (basic checks only)

pub fn rdtscp(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRdtscp, 

RDTSCP instruction

Instruction	Opcode	CPUID
RDTSCP	0F 01 F9	RDTSCP

Errors

Fails if an operand is invalid (basic checks only)

pub fn rdudbg(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRdudbg, 

RDUDBG instruction

Instruction	Opcode	CPUID
RDUDBG	0F 0E	UDBG

Errors

Fails if an operand is invalid (basic checks only)

pub fn reservednop_0f0d<T, U>(
    &mut self,
    op0: T,
    op1: U
) -> Result<(), IcedError> where
    Self: CodeAsmReservednop_0f0d<T, U>, 

RESERVEDNOP_0F0D instruction

Instruction	Opcode	CPUID
RESERVEDNOP r/m16, r16	o16 0F 0D /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32	o32 0F 0D /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64	o64 0F 0D /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn reservednop_0f18<T, U>(
    &mut self,
    op0: T,
    op1: U
) -> Result<(), IcedError> where
    Self: CodeAsmReservednop_0f18<T, U>, 

RESERVEDNOP_0F18 instruction

Instruction	Opcode	CPUID
RESERVEDNOP r/m16, r16	o16 0F 18 /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32	o32 0F 18 /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64	o64 0F 18 /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn reservednop_0f19<T, U>(
    &mut self,
    op0: T,
    op1: U
) -> Result<(), IcedError> where
    Self: CodeAsmReservednop_0f19<T, U>, 

RESERVEDNOP_0F19 instruction

Instruction	Opcode	CPUID
RESERVEDNOP r/m16, r16	o16 0F 19 /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32	o32 0F 19 /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64	o64 0F 19 /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn reservednop_0f1a<T, U>(
    &mut self,
    op0: T,
    op1: U
) -> Result<(), IcedError> where
    Self: CodeAsmReservednop_0f1a<T, U>, 

RESERVEDNOP_0F1A instruction

Instruction	Opcode	CPUID
RESERVEDNOP r/m16, r16	o16 0F 1A /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32	o32 0F 1A /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64	o64 0F 1A /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn reservednop_0f1b<T, U>(
    &mut self,
    op0: T,
    op1: U
) -> Result<(), IcedError> where
    Self: CodeAsmReservednop_0f1b<T, U>, 

RESERVEDNOP_0F1B instruction

Instruction	Opcode	CPUID
RESERVEDNOP r/m16, r16	o16 0F 1B /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32	o32 0F 1B /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64	o64 0F 1B /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn reservednop_0f1c<T, U>(
    &mut self,
    op0: T,
    op1: U
) -> Result<(), IcedError> where
    Self: CodeAsmReservednop_0f1c<T, U>, 

RESERVEDNOP_0F1C instruction

Instruction	Opcode	CPUID
RESERVEDNOP r/m16, r16	o16 0F 1C /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32	o32 0F 1C /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64	o64 0F 1C /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn reservednop_0f1d<T, U>(
    &mut self,
    op0: T,
    op1: U
) -> Result<(), IcedError> where
    Self: CodeAsmReservednop_0f1d<T, U>, 

RESERVEDNOP_0F1D instruction

Instruction	Opcode	CPUID
RESERVEDNOP r/m16, r16	o16 0F 1D /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32	o32 0F 1D /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64	o64 0F 1D /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn reservednop_0f1e<T, U>(
    &mut self,
    op0: T,
    op1: U
) -> Result<(), IcedError> where
    Self: CodeAsmReservednop_0f1e<T, U>, 

RESERVEDNOP_0F1E instruction

Instruction	Opcode	CPUID
RESERVEDNOP r/m16, r16	o16 0F 1E /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32	o32 0F 1E /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64	o64 0F 1E /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn reservednop_0f1f<T, U>(
    &mut self,
    op0: T,
    op1: U
) -> Result<(), IcedError> where
    Self: CodeAsmReservednop_0f1f<T, U>, 

RESERVEDNOP_0F1F instruction

Instruction	Opcode	CPUID
RESERVEDNOP r/m16, r16	o16 0F 1F /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32	o32 0F 1F /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64	o64 0F 1F /r	CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ret(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRet, 

RET instruction

Instruction	Opcode	CPUID
RET	o16 C3	8086+
RET	o32 C3	386+
RET	o64 C3	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn ret_1<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRet1<T>, 

RET instruction

Instruction	Opcode	CPUID
RET imm16	o16 C2 iw	8086+
RET imm16	o32 C2 iw	386+
RET imm16	o64 C2 iw	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn retf(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRetf, 

RETF instruction

Instruction	Opcode	CPUID
RETF	o16 CB	8086+
RETF	o32 CB	386+
RETF	o64 CB	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn retf_1<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRetf1<T>, 

RETF instruction

Instruction	Opcode	CPUID
RETF imm16	o16 CA iw	8086+
RETF imm16	o32 CA iw	386+
RETF imm16	o64 CA iw	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rmpadjust(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRmpadjust, 

RMPADJUST instruction

Instruction	Opcode	CPUID
RMPADJUST	F3 0F 01 FE	SEV-SNP

Errors

Fails if an operand is invalid (basic checks only)

pub fn rmpupdate(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRmpupdate, 

RMPUPDATE instruction

Instruction	Opcode	CPUID
RMPUPDATE	F2 0F 01 FE	SEV-SNP

Errors

Fails if an operand is invalid (basic checks only)

pub fn rol<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmRol<T, U>, 

ROL instruction

Instruction	Opcode	CPUID
ROL r/m8, imm8	C0 /0 ib	186+
ROL r/m16, imm8	o16 C1 /0 ib	186+
ROL r/m32, imm8	o32 C1 /0 ib	386+
ROL r/m64, imm8	o64 C1 /0 ib	X64
ROL r/m8, 1	D0 /0	8086+
ROL r/m16, 1	o16 D1 /0	8086+
ROL r/m32, 1	o32 D1 /0	386+
ROL r/m64, 1	o64 D1 /0	X64
ROL r/m8, CL	D2 /0	8086+
ROL r/m16, CL	o16 D3 /0	8086+
ROL r/m32, CL	o32 D3 /0	386+
ROL r/m64, CL	o64 D3 /0	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ror<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmRor<T, U>, 

ROR instruction

Instruction	Opcode	CPUID
ROR r/m8, imm8	C0 /1 ib	186+
ROR r/m16, imm8	o16 C1 /1 ib	186+
ROR r/m32, imm8	o32 C1 /1 ib	386+
ROR r/m64, imm8	o64 C1 /1 ib	X64
ROR r/m8, 1	D0 /1	8086+
ROR r/m16, 1	o16 D1 /1	8086+
ROR r/m32, 1	o32 D1 /1	386+
ROR r/m64, 1	o64 D1 /1	X64
ROR r/m8, CL	D2 /1	8086+
ROR r/m16, CL	o16 D3 /1	8086+
ROR r/m32, CL	o32 D3 /1	386+
ROR r/m64, CL	o64 D3 /1	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn rorx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmRorx<T, U, V>, 

RORX instruction

Instruction	Opcode	CPUID
RORX r32, r/m32, imm8	VEX.LZ.F2.0F3A.W0 F0 /r ib	BMI2
RORX r64, r/m64, imm8	VEX.LZ.F2.0F3A.W1 F0 /r ib	BMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn roundpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmRoundpd<T, U, V>, 

ROUNDPD instruction

Instruction	Opcode	CPUID
ROUNDPD xmm1, xmm2/m128, imm8	66 0F 3A 09 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn roundps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmRoundps<T, U, V>, 

ROUNDPS instruction

Instruction	Opcode	CPUID
ROUNDPS xmm1, xmm2/m128, imm8	66 0F 3A 08 /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn roundsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmRoundsd<T, U, V>, 

ROUNDSD instruction

Instruction	Opcode	CPUID
ROUNDSD xmm1, xmm2/m64, imm8	66 0F 3A 0B /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn roundss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmRoundss<T, U, V>, 

ROUNDSS instruction

Instruction	Opcode	CPUID
ROUNDSS xmm1, xmm2/m32, imm8	66 0F 3A 0A /r ib	SSE4.1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn rsdc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmRsdc<T, U>, 

RSDC instruction

Instruction	Opcode	CPUID
RSDC Sreg, m80	0F 79 /r	Cyrix, AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn rsldt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRsldt<T>, 

RSLDT instruction

Instruction	Opcode	CPUID
RSLDT m80	0F 7B /0	Cyrix, AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rsm(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmRsm, 

RSM instruction

Instruction	Opcode	CPUID
RSM	0F AA	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn rsqrtps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmRsqrtps<T, U>, 

RSQRTPS instruction

Instruction	Opcode	CPUID
RSQRTPS xmm1, xmm2/m128	NP 0F 52 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn rsqrtss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmRsqrtss<T, U>, 

RSQRTSS instruction

Instruction	Opcode	CPUID
RSQRTSS xmm1, xmm2/m32	F3 0F 52 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn rstorssp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRstorssp<T>, 

RSTORSSP instruction

Instruction	Opcode	CPUID
RSTORSSP m64	F3 0F 01 /5	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn rsts<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmRsts<T>, 

RSTS instruction

Instruction	Opcode	CPUID
RSTS m80	0F 7D /0	Cyrix, AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn sahf(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSahf, 

SAHF instruction

Instruction	Opcode	CPUID
SAHF	9E	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn sal<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSal<T, U>, 

SAL instruction

Instruction	Opcode	CPUID
SAL r/m8, imm8	C0 /6 ib	186+
SAL r/m16, imm8	o16 C1 /6 ib	186+
SAL r/m32, imm8	o32 C1 /6 ib	386+
SAL r/m64, imm8	o64 C1 /6 ib	X64
SAL r/m8, 1	D0 /6	8086+
SAL r/m16, 1	o16 D1 /6	8086+
SAL r/m32, 1	o32 D1 /6	386+
SAL r/m64, 1	o64 D1 /6	X64
SAL r/m8, CL	D2 /6	8086+
SAL r/m16, CL	o16 D3 /6	8086+
SAL r/m32, CL	o32 D3 /6	386+
SAL r/m64, CL	o64 D3 /6	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn salc(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSalc, 

SALC instruction

Instruction	Opcode	CPUID
SALC	D6	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn sar<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSar<T, U>, 

SAR instruction

Instruction	Opcode	CPUID
SAR r/m8, imm8	C0 /7 ib	186+
SAR r/m16, imm8	o16 C1 /7 ib	186+
SAR r/m32, imm8	o32 C1 /7 ib	386+
SAR r/m64, imm8	o64 C1 /7 ib	X64
SAR r/m8, 1	D0 /7	8086+
SAR r/m16, 1	o16 D1 /7	8086+
SAR r/m32, 1	o32 D1 /7	386+
SAR r/m64, 1	o64 D1 /7	X64
SAR r/m8, CL	D2 /7	8086+
SAR r/m16, CL	o16 D3 /7	8086+
SAR r/m32, CL	o32 D3 /7	386+
SAR r/m64, CL	o64 D3 /7	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn sarx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmSarx<T, U, V>, 

SARX instruction

Instruction	Opcode	CPUID
SARX r32a, r/m32, r32b	VEX.LZ.F3.0F38.W0 F7 /r	BMI2
SARX r64a, r/m64, r64b	VEX.LZ.F3.0F38.W1 F7 /r	BMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn saveprevssp(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSaveprevssp, 

SAVEPREVSSP instruction

Instruction	Opcode	CPUID
SAVEPREVSSP	F3 0F 01 EA	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

pub fn sbb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSbb<T, U>, 

SBB instruction

Instruction	Opcode	CPUID
SBB r/m8, r8	18 /r	8086+
SBB r/m16, r16	o16 19 /r	8086+
SBB r/m32, r32	o32 19 /r	386+
SBB r/m64, r64	o64 19 /r	X64
SBB r8, r/m8	1A /r	8086+
SBB r16, r/m16	o16 1B /r	8086+
SBB r32, r/m32	o32 1B /r	386+
SBB r64, r/m64	o64 1B /r	X64
SBB AL, imm8	1C ib	8086+
SBB AX, imm16	o16 1D iw	8086+
SBB EAX, imm32	o32 1D id	386+
SBB RAX, imm32	o64 1D id	X64
SBB r/m8, imm8	80 /3 ib	8086+
SBB r/m16, imm16	o16 81 /3 iw	8086+
SBB r/m32, imm32	o32 81 /3 id	386+
SBB r/m64, imm32	o64 81 /3 id	X64
SBB r/m16, imm8	o16 83 /3 ib	8086+
SBB r/m32, imm8	o32 83 /3 ib	386+
SBB r/m64, imm8	o64 83 /3 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn scasb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmScasb, 

SCASB instruction

Instruction	Opcode	CPUID
SCASB	AE	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn scasd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmScasd, 

SCASD instruction

Instruction	Opcode	CPUID
SCASD	o32 AF	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn scasq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmScasq, 

SCASQ instruction

Instruction	Opcode	CPUID
SCASQ	o64 AF	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn scasw(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmScasw, 

SCASW instruction

Instruction	Opcode	CPUID
SCASW	o16 AF	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn seamcall(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSeamcall, 

SEAMCALL instruction

Instruction	Opcode	CPUID
SEAMCALL	66 0F 01 CF	TDX

Errors

Fails if an operand is invalid (basic checks only)

pub fn seamops(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSeamops, 

SEAMOPS instruction

Instruction	Opcode	CPUID
SEAMOPS	66 0F 01 CE	TDX

Errors

Fails if an operand is invalid (basic checks only)

pub fn seamret(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSeamret, 

SEAMRET instruction

Instruction	Opcode	CPUID
SEAMRET	66 0F 01 CD	TDX

Errors

Fails if an operand is invalid (basic checks only)

pub fn senduipi<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSenduipi<T>, 

SENDUIPI instruction

Instruction	Opcode	CPUID
SENDUIPI r64	F3 0F C7 /6	UINTR

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn serialize(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSerialize, 

SERIALIZE instruction

Instruction	Opcode	CPUID
SERIALIZE	NP 0F 01 E8	SERIALIZE

Errors

Fails if an operand is invalid (basic checks only)

pub fn seta<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSeta<T>, 

SETA instruction

Instruction	Opcode	CPUID
SETA r/m8	0F 97 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setae<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetae<T>, 

SETAE instruction

Instruction	Opcode	CPUID
SETAE r/m8	0F 93 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setb<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetb<T>, 

SETB instruction

Instruction	Opcode	CPUID
SETB r/m8	0F 92 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setbe<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetbe<T>, 

SETBE instruction

Instruction	Opcode	CPUID
SETBE r/m8	0F 96 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setc<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetc<T>, 

SETC instruction

Instruction	Opcode	CPUID
SETB r/m8	0F 92 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn sete<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSete<T>, 

SETE instruction

Instruction	Opcode	CPUID
SETE r/m8	0F 94 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setg<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetg<T>, 

SETG instruction

Instruction	Opcode	CPUID
SETG r/m8	0F 9F /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setge<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetge<T>, 

SETGE instruction

Instruction	Opcode	CPUID
SETGE r/m8	0F 9D /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setl<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetl<T>, 

SETL instruction

Instruction	Opcode	CPUID
SETL r/m8	0F 9C /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setle<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetle<T>, 

SETLE instruction

Instruction	Opcode	CPUID
SETLE r/m8	0F 9E /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setna<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetna<T>, 

SETNA instruction

Instruction	Opcode	CPUID
SETBE r/m8	0F 96 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setnae<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetnae<T>, 

SETNAE instruction

Instruction	Opcode	CPUID
SETB r/m8	0F 92 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setnb<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetnb<T>, 

SETNB instruction

Instruction	Opcode	CPUID
SETAE r/m8	0F 93 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setnbe<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetnbe<T>, 

SETNBE instruction

Instruction	Opcode	CPUID
SETA r/m8	0F 97 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setnc<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetnc<T>, 

SETNC instruction

Instruction	Opcode	CPUID
SETAE r/m8	0F 93 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setne<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetne<T>, 

SETNE instruction

Instruction	Opcode	CPUID
SETNE r/m8	0F 95 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setng<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetng<T>, 

SETNG instruction

Instruction	Opcode	CPUID
SETLE r/m8	0F 9E /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setnge<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetnge<T>, 

SETNGE instruction

Instruction	Opcode	CPUID
SETL r/m8	0F 9C /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setnl<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetnl<T>, 

SETNL instruction

Instruction	Opcode	CPUID
SETGE r/m8	0F 9D /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setnle<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetnle<T>, 

SETNLE instruction

Instruction	Opcode	CPUID
SETG r/m8	0F 9F /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setno<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetno<T>, 

SETNO instruction

Instruction	Opcode	CPUID
SETNO r/m8	0F 91 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setnp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetnp<T>, 

SETNP instruction

Instruction	Opcode	CPUID
SETNP r/m8	0F 9B /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setns<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetns<T>, 

SETNS instruction

Instruction	Opcode	CPUID
SETNS r/m8	0F 99 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setnz<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetnz<T>, 

SETNZ instruction

Instruction	Opcode	CPUID
SETNE r/m8	0F 95 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn seto<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSeto<T>, 

SETO instruction

Instruction	Opcode	CPUID
SETO r/m8	0F 90 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setp<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetp<T>, 

SETP instruction

Instruction	Opcode	CPUID
SETP r/m8	0F 9A /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setpe<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetpe<T>, 

SETPE instruction

Instruction	Opcode	CPUID
SETP r/m8	0F 9A /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setpo<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetpo<T>, 

SETPO instruction

Instruction	Opcode	CPUID
SETNP r/m8	0F 9B /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn sets<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSets<T>, 

SETS instruction

Instruction	Opcode	CPUID
SETS r/m8	0F 98 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn setssbsy(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSetssbsy, 

SETSSBSY instruction

Instruction	Opcode	CPUID
SETSSBSY	F3 0F 01 E8	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

pub fn setz<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSetz<T>, 

SETZ instruction

Instruction	Opcode	CPUID
SETE r/m8	0F 94 /r	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn sfence(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSfence, 

SFENCE instruction

Instruction	Opcode	CPUID
SFENCE	NP 0F AE F8	SSE

Errors

Fails if an operand is invalid (basic checks only)

pub fn sgdt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSgdt<T>, 

SGDT instruction

Instruction	Opcode	CPUID
SGDT m	0F 01 /0	X64
SGDT m	o16 0F 01 /0	286+
SGDT m	o32 0F 01 /0	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn sha1msg1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSha1msg1<T, U>, 

SHA1MSG1 instruction

Instruction	Opcode	CPUID
SHA1MSG1 xmm1, xmm2/m128	NP 0F 38 C9 /r	SHA

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn sha1msg2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSha1msg2<T, U>, 

SHA1MSG2 instruction

Instruction	Opcode	CPUID
SHA1MSG2 xmm1, xmm2/m128	NP 0F 38 CA /r	SHA

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn sha1nexte<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSha1nexte<T, U>, 

SHA1NEXTE instruction

Instruction	Opcode	CPUID
SHA1NEXTE xmm1, xmm2/m128	NP 0F 38 C8 /r	SHA

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn sha1rnds4<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmSha1rnds4<T, U, V>, 

SHA1RNDS4 instruction

Instruction	Opcode	CPUID
SHA1RNDS4 xmm1, xmm2/m128, imm8	NP 0F 3A CC /r ib	SHA

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn sha256msg1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSha256msg1<T, U>, 

SHA256MSG1 instruction

Instruction	Opcode	CPUID
SHA256MSG1 xmm1, xmm2/m128	NP 0F 38 CC /r	SHA

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn sha256msg2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSha256msg2<T, U>, 

SHA256MSG2 instruction

Instruction	Opcode	CPUID
SHA256MSG2 xmm1, xmm2/m128	NP 0F 38 CD /r	SHA

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn sha256rnds2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSha256rnds2<T, U>, 

SHA256RNDS2 instruction

Instruction	Opcode	CPUID
SHA256RNDS2 xmm1, xmm2/m128, <XMM0>	NP 0F 38 CB /r	SHA

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn shl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmShl<T, U>, 

SHL instruction

Instruction	Opcode	CPUID
SHL r/m8, imm8	C0 /4 ib	186+
SHL r/m16, imm8	o16 C1 /4 ib	186+
SHL r/m32, imm8	o32 C1 /4 ib	386+
SHL r/m64, imm8	o64 C1 /4 ib	X64
SHL r/m8, 1	D0 /4	8086+
SHL r/m16, 1	o16 D1 /4	8086+
SHL r/m32, 1	o32 D1 /4	386+
SHL r/m64, 1	o64 D1 /4	X64
SHL r/m8, CL	D2 /4	8086+
SHL r/m16, CL	o16 D3 /4	8086+
SHL r/m32, CL	o32 D3 /4	386+
SHL r/m64, CL	o64 D3 /4	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn shld<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmShld<T, U, V>, 

SHLD instruction

Instruction	Opcode	CPUID
SHLD r/m16, r16, imm8	o16 0F A4 /r ib	386+
SHLD r/m32, r32, imm8	o32 0F A4 /r ib	386+
SHLD r/m64, r64, imm8	o64 0F A4 /r ib	X64
SHLD r/m16, r16, CL	o16 0F A5 /r	386+
SHLD r/m32, r32, CL	o32 0F A5 /r	386+
SHLD r/m64, r64, CL	o64 0F A5 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn shlx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmShlx<T, U, V>, 

SHLX instruction

Instruction	Opcode	CPUID
SHLX r32a, r/m32, r32b	VEX.LZ.66.0F38.W0 F7 /r	BMI2
SHLX r64a, r/m64, r64b	VEX.LZ.66.0F38.W1 F7 /r	BMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn shr<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmShr<T, U>, 

SHR instruction

Instruction	Opcode	CPUID
SHR r/m8, imm8	C0 /5 ib	186+
SHR r/m16, imm8	o16 C1 /5 ib	186+
SHR r/m32, imm8	o32 C1 /5 ib	386+
SHR r/m64, imm8	o64 C1 /5 ib	X64
SHR r/m8, 1	D0 /5	8086+
SHR r/m16, 1	o16 D1 /5	8086+
SHR r/m32, 1	o32 D1 /5	386+
SHR r/m64, 1	o64 D1 /5	X64
SHR r/m8, CL	D2 /5	8086+
SHR r/m16, CL	o16 D3 /5	8086+
SHR r/m32, CL	o32 D3 /5	386+
SHR r/m64, CL	o64 D3 /5	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn shrd<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmShrd<T, U, V>, 

SHRD instruction

Instruction	Opcode	CPUID
SHRD r/m16, r16, imm8	o16 0F AC /r ib	386+
SHRD r/m32, r32, imm8	o32 0F AC /r ib	386+
SHRD r/m64, r64, imm8	o64 0F AC /r ib	X64
SHRD r/m16, r16, CL	o16 0F AD /r	386+
SHRD r/m32, r32, CL	o32 0F AD /r	386+
SHRD r/m64, r64, CL	o64 0F AD /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn shrx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmShrx<T, U, V>, 

SHRX instruction

Instruction	Opcode	CPUID
SHRX r32a, r/m32, r32b	VEX.LZ.F2.0F38.W0 F7 /r	BMI2
SHRX r64a, r/m64, r64b	VEX.LZ.F2.0F38.W1 F7 /r	BMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn shufpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmShufpd<T, U, V>, 

SHUFPD instruction

Instruction	Opcode	CPUID
SHUFPD xmm1, xmm2/m128, imm8	66 0F C6 /r ib	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn shufps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmShufps<T, U, V>, 

SHUFPS instruction

Instruction	Opcode	CPUID
SHUFPS xmm1, xmm2/m128, imm8	NP 0F C6 /r ib	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn sidt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSidt<T>, 

SIDT instruction

Instruction	Opcode	CPUID
SIDT m	0F 01 /1	X64
SIDT m	o16 0F 01 /1	286+
SIDT m	o32 0F 01 /1	386+

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn skinit(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSkinit, 

SKINIT instruction

Instruction	Opcode	CPUID
SKINIT	0F 01 DE	SKINIT or SVM

Errors

Fails if an operand is invalid (basic checks only)

pub fn sldt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSldt<T>, 

SLDT instruction

Instruction	Opcode	CPUID
SLDT r/m16	o16 0F 00 /0	286+
SLDT r32/m16	o32 0F 00 /0	386+
SLDT r64/m16	o64 0F 00 /0	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn slwpcb<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSlwpcb<T>, 

SLWPCB instruction

Instruction	Opcode	CPUID
SLWPCB r32	XOP.L0.X9.W0 12 /1	LWP
SLWPCB r64	XOP.L0.X9.W1 12 /1	LWP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn smint(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSmint, 

SMINT instruction

Instruction	Opcode	CPUID
SMINT	0F 38	Cyrix 6x86MX+, AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

pub fn smint_0f7e(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSmint_0f7e, 

SMINT_0F7E instruction

Instruction	Opcode	CPUID
SMINT	0F 7E	Cyrix 6x86 or earlier

Errors

Fails if an operand is invalid (basic checks only)

pub fn smsw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSmsw<T>, 

SMSW instruction

Instruction	Opcode	CPUID
SMSW r/m16	o16 0F 01 /4	286+
SMSW r32/m16	o32 0F 01 /4	386+
SMSW r64/m16	o64 0F 01 /4	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn sqrtpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSqrtpd<T, U>, 

SQRTPD instruction

Instruction	Opcode	CPUID
SQRTPD xmm1, xmm2/m128	66 0F 51 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn sqrtps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSqrtps<T, U>, 

SQRTPS instruction

Instruction	Opcode	CPUID
SQRTPS xmm1, xmm2/m128	NP 0F 51 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn sqrtsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSqrtsd<T, U>, 

SQRTSD instruction

Instruction	Opcode	CPUID
SQRTSD xmm1, xmm2/m64	F2 0F 51 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn sqrtss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSqrtss<T, U>, 

SQRTSS instruction

Instruction	Opcode	CPUID
SQRTSS xmm1, xmm2/m32	F3 0F 51 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn stac(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmStac, 

STAC instruction

Instruction	Opcode	CPUID
STAC	NP 0F 01 CB	SMAP

Errors

Fails if an operand is invalid (basic checks only)

pub fn stc(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmStc, 

STC instruction

Instruction	Opcode	CPUID
STC	F9	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn std(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmStd, 

STD instruction

Instruction	Opcode	CPUID
STD	FD	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn stgi(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmStgi, 

STGI instruction

Instruction	Opcode	CPUID
STGI	0F 01 DC	SKINIT or SVM

Errors

Fails if an operand is invalid (basic checks only)

pub fn sti(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSti, 

STI instruction

Instruction	Opcode	CPUID
STI	FB	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn stmxcsr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmStmxcsr<T>, 

STMXCSR instruction

Instruction	Opcode	CPUID
STMXCSR m32	NP 0F AE /3	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn stosb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmStosb, 

STOSB instruction

Instruction	Opcode	CPUID
STOSB	AA	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn stosd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmStosd, 

STOSD instruction

Instruction	Opcode	CPUID
STOSD	o32 AB	386+

Errors

Fails if an operand is invalid (basic checks only)

pub fn stosq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmStosq, 

STOSQ instruction

Instruction	Opcode	CPUID
STOSQ	o64 AB	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn stosw(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmStosw, 

STOSW instruction

Instruction	Opcode	CPUID
STOSW	o16 AB	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn str<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmStr<T>, 

STR instruction

Instruction	Opcode	CPUID
STR r/m16	o16 0F 00 /1	286+
STR r32/m16	o32 0F 00 /1	386+
STR r64/m16	o64 0F 00 /1	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn sttilecfg<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSttilecfg<T>, 

STTILECFG instruction

Instruction	Opcode	CPUID
STTILECFG m512	VEX.128.66.0F38.W0 49 !(11):000:bbb	AMX-TILE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn stui(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmStui, 

STUI instruction

Instruction	Opcode	CPUID
STUI	F3 0F 01 EF	UINTR

Errors

Fails if an operand is invalid (basic checks only)

pub fn sub<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSub<T, U>, 

SUB instruction

Instruction	Opcode	CPUID
SUB r/m8, r8	28 /r	8086+
SUB r/m16, r16	o16 29 /r	8086+
SUB r/m32, r32	o32 29 /r	386+
SUB r/m64, r64	o64 29 /r	X64
SUB r8, r/m8	2A /r	8086+
SUB r16, r/m16	o16 2B /r	8086+
SUB r32, r/m32	o32 2B /r	386+
SUB r64, r/m64	o64 2B /r	X64
SUB AL, imm8	2C ib	8086+
SUB AX, imm16	o16 2D iw	8086+
SUB EAX, imm32	o32 2D id	386+
SUB RAX, imm32	o64 2D id	X64
SUB r/m8, imm8	80 /5 ib	8086+
SUB r/m16, imm16	o16 81 /5 iw	8086+
SUB r/m32, imm32	o32 81 /5 id	386+
SUB r/m64, imm32	o64 81 /5 id	X64
SUB r/m16, imm8	o16 83 /5 ib	8086+
SUB r/m32, imm8	o32 83 /5 ib	386+
SUB r/m64, imm8	o64 83 /5 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn subpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSubpd<T, U>, 

SUBPD instruction

Instruction	Opcode	CPUID
SUBPD xmm1, xmm2/m128	66 0F 5C /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn subps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSubps<T, U>, 

SUBPS instruction

Instruction	Opcode	CPUID
SUBPS xmm1, xmm2/m128	NP 0F 5C /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn subsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSubsd<T, U>, 

SUBSD instruction

Instruction	Opcode	CPUID
SUBSD xmm1, xmm2/m64	F2 0F 5C /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn subss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSubss<T, U>, 

SUBSS instruction

Instruction	Opcode	CPUID
SUBSS xmm1, xmm2/m32	F3 0F 5C /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn svdc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmSvdc<T, U>, 

SVDC instruction

Instruction	Opcode	CPUID
SVDC m80, Sreg	0F 78 /r	Cyrix, AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn svldt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSvldt<T>, 

SVLDT instruction

Instruction	Opcode	CPUID
SVLDT m80	0F 7A /0	Cyrix, AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn svts<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmSvts<T>, 

SVTS instruction

Instruction	Opcode	CPUID
SVTS m80	0F 7C /0	Cyrix, AMD Geode GX/LX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn swapgs(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSwapgs, 

SWAPGS instruction

Instruction	Opcode	CPUID
SWAPGS	0F 01 F8	X64

Errors

Fails if an operand is invalid (basic checks only)

pub fn syscall(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSyscall, 

SYSCALL instruction

Instruction	Opcode	CPUID
SYSCALL	0F 05	SYSCALL

Errors

Fails if an operand is invalid (basic checks only)

pub fn sysenter(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSysenter, 

SYSENTER instruction

Instruction	Opcode	CPUID
SYSENTER	0F 34	SEP

Errors

Fails if an operand is invalid (basic checks only)

pub fn sysexit(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSysexit, 

SYSEXIT instruction

Instruction	Opcode	CPUID
SYSEXIT	0F 35	SEP

Errors

Fails if an operand is invalid (basic checks only)

pub fn sysexitq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSysexitq, 

SYSEXITQ instruction

Instruction	Opcode	CPUID
SYSEXITQ	o64 0F 35	SEP

Errors

Fails if an operand is invalid (basic checks only)

pub fn sysret(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSysret, 

SYSRET instruction

Instruction	Opcode	CPUID
SYSRET	0F 07	SYSCALL

Errors

Fails if an operand is invalid (basic checks only)

pub fn sysretq(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmSysretq, 

SYSRETQ instruction

Instruction	Opcode	CPUID
SYSRETQ	o64 0F 07	SYSCALL

Errors

Fails if an operand is invalid (basic checks only)

pub fn t1mskc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmT1mskc<T, U>, 

T1MSKC instruction

Instruction	Opcode	CPUID
T1MSKC r32, r/m32	XOP.L0.X9.W0 01 /7	TBM
T1MSKC r64, r/m64	XOP.L0.X9.W1 01 /7	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn tdcall(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmTdcall, 

TDCALL instruction

Instruction	Opcode	CPUID
TDCALL	66 0F 01 CC	TDX

Errors

Fails if an operand is invalid (basic checks only)

pub fn tdpbf16ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmTdpbf16ps<T, U, V>, 

TDPBF16PS instruction

Instruction	Opcode	CPUID
TDPBF16PS tmm1, tmm2, tmm3	VEX.128.F3.0F38.W0 5C 11:rrr:bbb	AMX-BF16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn tdpbssd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmTdpbssd<T, U, V>, 

TDPBSSD instruction

Instruction	Opcode	CPUID
TDPBSSD tmm1, tmm2, tmm3	VEX.128.F2.0F38.W0 5E 11:rrr:bbb	AMX-INT8

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn tdpbsud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmTdpbsud<T, U, V>, 

TDPBSUD instruction

Instruction	Opcode	CPUID
TDPBSUD tmm1, tmm2, tmm3	VEX.128.F3.0F38.W0 5E 11:rrr:bbb	AMX-INT8

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn tdpbusd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmTdpbusd<T, U, V>, 

TDPBUSD instruction

Instruction	Opcode	CPUID
TDPBUSD tmm1, tmm2, tmm3	VEX.128.66.0F38.W0 5E 11:rrr:bbb	AMX-INT8

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn tdpbuud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmTdpbuud<T, U, V>, 

TDPBUUD instruction

Instruction	Opcode	CPUID
TDPBUUD tmm1, tmm2, tmm3	VEX.128.0F38.W0 5E 11:rrr:bbb	AMX-INT8

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn test<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmTest<T, U>, 

TEST instruction

Instruction	Opcode	CPUID
TEST r/m8, r8	84 /r	8086+
TEST r/m16, r16	o16 85 /r	8086+
TEST r/m32, r32	o32 85 /r	386+
TEST r/m64, r64	o64 85 /r	X64
TEST AL, imm8	A8 ib	8086+
TEST AX, imm16	o16 A9 iw	8086+
TEST EAX, imm32	o32 A9 id	386+
TEST RAX, imm32	o64 A9 id	X64
TEST r/m8, imm8	F6 /0 ib	8086+
TEST r/m16, imm16	o16 F7 /0 iw	8086+
TEST r/m32, imm32	o32 F7 /0 id	386+
TEST r/m64, imm32	o64 F7 /0 id	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn testui(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmTestui, 

TESTUI instruction

Instruction	Opcode	CPUID
TESTUI	F3 0F 01 ED	UINTR

Errors

Fails if an operand is invalid (basic checks only)

pub fn tileloadd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmTileloadd<T, U>, 

TILELOADD instruction

Instruction	Opcode	CPUID
TILELOADD tmm1, sibmem	VEX.128.F2.0F38.W0 4B !(11):rrr:100	AMX-TILE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn tileloaddt1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmTileloaddt1<T, U>, 

TILELOADDT1 instruction

Instruction	Opcode	CPUID
TILELOADDT1 tmm1, sibmem	VEX.128.66.0F38.W0 4B !(11):rrr:100	AMX-TILE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn tilerelease(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmTilerelease, 

TILERELEASE instruction

Instruction	Opcode	CPUID
TILERELEASE	VEX.128.0F38.W0 49 C0	AMX-TILE

Errors

Fails if an operand is invalid (basic checks only)

pub fn tilestored<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmTilestored<T, U>, 

TILESTORED instruction

Instruction	Opcode	CPUID
TILESTORED sibmem, tmm1	VEX.128.F3.0F38.W0 4B !(11):rrr:100	AMX-TILE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn tilezero<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmTilezero<T>, 

TILEZERO instruction

Instruction	Opcode	CPUID
TILEZERO tmm1	VEX.128.F2.0F38.W0 49 11:rrr:000	AMX-TILE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn tlbsync(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmTlbsync, 

TLBSYNC instruction

Instruction	Opcode	CPUID
TLBSYNC	NP 0F 01 FF	INVLPGB

Errors

Fails if an operand is invalid (basic checks only)

pub fn tpause<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmTpause<T>, 

TPAUSE instruction

Instruction	Opcode	CPUID
TPAUSE r32, <edx>, <eax>	66 0F AE /6	WAITPKG
TPAUSE r64, <edx>, <eax>	66 o64 0F AE /6	WAITPKG

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn tzcnt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmTzcnt<T, U>, 

TZCNT instruction

Instruction	Opcode	CPUID
TZCNT r16, r/m16	o16 F3 0F BC /r	BMI1
TZCNT r32, r/m32	o32 F3 0F BC /r	BMI1
TZCNT r64, r/m64	F3 o64 0F BC /r	BMI1

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn tzmsk<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmTzmsk<T, U>, 

TZMSK instruction

Instruction	Opcode	CPUID
TZMSK r32, r/m32	XOP.L0.X9.W0 01 /4	TBM
TZMSK r64, r/m64	XOP.L0.X9.W1 01 /4	TBM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ucomisd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmUcomisd<T, U>, 

UCOMISD instruction

Instruction	Opcode	CPUID
UCOMISD xmm1, xmm2/m64	66 0F 2E /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ucomiss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmUcomiss<T, U>, 

UCOMISS instruction

Instruction	Opcode	CPUID
UCOMISS xmm1, xmm2/m32	NP 0F 2E /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ud0(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmUd0, 

UD0 instruction

Instruction	Opcode	CPUID
UD0	0F FF	286+

Errors

Fails if an operand is invalid (basic checks only)

pub fn ud0_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmUd02<T, U>, 

UD0 instruction

Instruction	Opcode	CPUID
UD0 r16, r/m16	o16 0F FF /r	286+
UD0 r32, r/m32	o32 0F FF /r	386+
UD0 r64, r/m64	o64 0F FF /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ud1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmUd1<T, U>, 

UD1 instruction

Instruction	Opcode	CPUID
UD1 r16, r/m16	o16 0F B9 /r	286+
UD1 r32, r/m32	o32 0F B9 /r	386+
UD1 r64, r/m64	o64 0F B9 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn ud2(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmUd2, 

UD2 instruction

Instruction	Opcode	CPUID
UD2	0F 0B	286+

Errors

Fails if an operand is invalid (basic checks only)

pub fn uiret(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmUiret, 

UIRET instruction

Instruction	Opcode	CPUID
UIRET	F3 0F 01 EC	UINTR

Errors

Fails if an operand is invalid (basic checks only)

pub fn umonitor<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmUmonitor<T>, 

UMONITOR instruction

Instruction	Opcode	CPUID
UMONITOR r16	a16 F3 0F AE /6	WAITPKG
UMONITOR r32	a32 F3 0F AE /6	WAITPKG
UMONITOR r64	a64 F3 0F AE /6	WAITPKG

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn umov<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmUmov<T, U>, 

UMOV instruction

Instruction	Opcode	CPUID
UMOV r/m8, r8	0F 10 /r	386/486
UMOV r/m16, r16	o16 0F 11 /r	386/486
UMOV r/m32, r32	o32 0F 11 /r	386/486
UMOV r8, r/m8	0F 12 /r	386/486
UMOV r16, r/m16	o16 0F 13 /r	386/486
UMOV r32, r/m32	o32 0F 13 /r	386/486

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn umwait<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmUmwait<T>, 

UMWAIT instruction

Instruction	Opcode	CPUID
UMWAIT r32, <edx>, <eax>	F2 0F AE /6	WAITPKG
UMWAIT r64, <edx>, <eax>	F2 o64 0F AE /6	WAITPKG

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn unpckhpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmUnpckhpd<T, U>, 

UNPCKHPD instruction

Instruction	Opcode	CPUID
UNPCKHPD xmm1, xmm2/m128	66 0F 15 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn unpckhps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmUnpckhps<T, U>, 

UNPCKHPS instruction

Instruction	Opcode	CPUID
UNPCKHPS xmm1, xmm2/m128	NP 0F 15 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn unpcklpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmUnpcklpd<T, U>, 

UNPCKLPD instruction

Instruction	Opcode	CPUID
UNPCKLPD xmm1, xmm2/m128	66 0F 14 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn unpcklps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmUnpcklps<T, U>, 

UNPCKLPS instruction

Instruction	Opcode	CPUID
UNPCKLPS xmm1, xmm2/m128	NP 0F 14 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn v4fmaddps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmV4fmaddps<T, U, V>, 

V4FMADDPS instruction

Instruction	Opcode	CPUID
V4FMADDPS zmm1 {k1}{z}, zmm2+3, m128	EVEX.512.F2.0F38.W0 9A /r	AVX512_4FMAPS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn v4fmaddss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmV4fmaddss<T, U, V>, 

V4FMADDSS instruction

Instruction	Opcode	CPUID
V4FMADDSS xmm1 {k1}{z}, xmm2+3, m128	EVEX.LIG.F2.0F38.W0 9B /r	AVX512_4FMAPS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn v4fnmaddps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmV4fnmaddps<T, U, V>, 

V4FNMADDPS instruction

Instruction	Opcode	CPUID
V4FNMADDPS zmm1 {k1}{z}, zmm2+3, m128	EVEX.512.F2.0F38.W0 AA /r	AVX512_4FMAPS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn v4fnmaddss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmV4fnmaddss<T, U, V>, 

V4FNMADDSS instruction

Instruction	Opcode	CPUID
V4FNMADDSS xmm1 {k1}{z}, xmm2+3, m128	EVEX.LIG.F2.0F38.W0 AB /r	AVX512_4FMAPS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaddpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaddpd<T, U, V>, 

VADDPD instruction

Instruction	Opcode	CPUID
VADDPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 58 /r	AVX
VADDPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 58 /r	AVX
VADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 58 /r	AVX512VL AVX512F
VADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 58 /r	AVX512VL AVX512F
VADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F.W1 58 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaddph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaddph<T, U, V>, 

VADDPH instruction

Instruction	Opcode	CPUID
VADDPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.MAP5.W0 58 /r	AVX512VL AVX512-FP16
VADDPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.MAP5.W0 58 /r	AVX512VL AVX512-FP16
VADDPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.MAP5.W0 58 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaddps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaddps<T, U, V>, 

VADDPS instruction

Instruction	Opcode	CPUID
VADDPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 58 /r	AVX
VADDPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 58 /r	AVX
VADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 58 /r	AVX512VL AVX512F
VADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 58 /r	AVX512VL AVX512F
VADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.0F.W0 58 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaddsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaddsd<T, U, V>, 

VADDSD instruction

Instruction	Opcode	CPUID
VADDSD xmm1, xmm2, xmm3/m64	VEX.LIG.F2.0F.WIG 58 /r	AVX
VADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.F2.0F.W1 58 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaddsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaddsh<T, U, V>, 

VADDSH instruction

Instruction	Opcode	CPUID
VADDSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.F3.MAP5.W0 58 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaddss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaddss<T, U, V>, 

VADDSS instruction

Instruction	Opcode	CPUID
VADDSS xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 58 /r	AVX
VADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.F3.0F.W0 58 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaddsubpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaddsubpd<T, U, V>, 

VADDSUBPD instruction

Instruction	Opcode	CPUID
VADDSUBPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG D0 /r	AVX
VADDSUBPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG D0 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaddsubps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaddsubps<T, U, V>, 

VADDSUBPS instruction

Instruction	Opcode	CPUID
VADDSUBPS xmm1, xmm2, xmm3/m128	VEX.128.F2.0F.WIG D0 /r	AVX
VADDSUBPS ymm1, ymm2, ymm3/m256	VEX.256.F2.0F.WIG D0 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaesdec<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaesdec<T, U, V>, 

VAESDEC instruction

Instruction	Opcode	CPUID
VAESDEC xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG DE /r	AES AVX
VAESDEC ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG DE /r	VAES
VAESDEC xmm1, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG DE /r	AVX512VL VAES
VAESDEC ymm1, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG DE /r	AVX512VL VAES
VAESDEC zmm1, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG DE /r	AVX512F VAES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaesdeclast<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaesdeclast<T, U, V>, 

VAESDECLAST instruction

Instruction	Opcode	CPUID
VAESDECLAST xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG DF /r	AES AVX
VAESDECLAST ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG DF /r	VAES
VAESDECLAST xmm1, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG DF /r	AVX512VL VAES
VAESDECLAST ymm1, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG DF /r	AVX512VL VAES
VAESDECLAST zmm1, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG DF /r	AVX512F VAES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaesenc<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaesenc<T, U, V>, 

VAESENC instruction

Instruction	Opcode	CPUID
VAESENC xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG DC /r	AES AVX
VAESENC ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG DC /r	VAES
VAESENC xmm1, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG DC /r	AVX512VL VAES
VAESENC ymm1, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG DC /r	AVX512VL VAES
VAESENC zmm1, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG DC /r	AVX512F VAES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaesenclast<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaesenclast<T, U, V>, 

VAESENCLAST instruction

Instruction	Opcode	CPUID
VAESENCLAST xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG DD /r	AES AVX
VAESENCLAST ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG DD /r	VAES
VAESENCLAST xmm1, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG DD /r	AVX512VL VAES
VAESENCLAST ymm1, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG DD /r	AVX512VL VAES
VAESENCLAST zmm1, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG DD /r	AVX512F VAES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vaesimc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVaesimc<T, U>, 

VAESIMC instruction

Instruction	Opcode	CPUID
VAESIMC xmm1, xmm2/m128	VEX.128.66.0F38.WIG DB /r	AES AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vaeskeygenassist<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVaeskeygenassist<T, U, V>, 

VAESKEYGENASSIST instruction

Instruction	Opcode	CPUID
VAESKEYGENASSIST xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.WIG DF /r ib	AES AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn valignd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmValignd<T, U, V, W>, 

VALIGND instruction

Instruction	Opcode	CPUID
VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 03 /r ib	AVX512VL AVX512F
VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 03 /r ib	AVX512VL AVX512F
VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 03 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn valignq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmValignq<T, U, V, W>, 

VALIGNQ instruction

Instruction	Opcode	CPUID
VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 03 /r ib	AVX512VL AVX512F
VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 03 /r ib	AVX512VL AVX512F
VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 03 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vandnpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVandnpd<T, U, V>, 

VANDNPD instruction

Instruction	Opcode	CPUID
VANDNPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 55 /r	AVX
VANDNPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 55 /r	AVX
VANDNPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 55 /r	AVX512VL AVX512DQ
VANDNPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 55 /r	AVX512VL AVX512DQ
VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 55 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vandnps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVandnps<T, U, V>, 

VANDNPS instruction

Instruction	Opcode	CPUID
VANDNPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 55 /r	AVX
VANDNPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 55 /r	AVX
VANDNPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 55 /r	AVX512VL AVX512DQ
VANDNPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 55 /r	AVX512VL AVX512DQ
VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.0F.W0 55 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vandpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVandpd<T, U, V>, 

VANDPD instruction

Instruction	Opcode	CPUID
VANDPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 54 /r	AVX
VANDPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 54 /r	AVX
VANDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 54 /r	AVX512VL AVX512DQ
VANDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 54 /r	AVX512VL AVX512DQ
VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 54 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vandps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVandps<T, U, V>, 

VANDPS instruction

Instruction	Opcode	CPUID
VANDPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 54 /r	AVX
VANDPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 54 /r	AVX
VANDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 54 /r	AVX512VL AVX512DQ
VANDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 54 /r	AVX512VL AVX512DQ
VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.0F.W0 54 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vblendmpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVblendmpd<T, U, V>, 

VBLENDMPD instruction

Instruction	Opcode	CPUID
VBLENDMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 65 /r	AVX512VL AVX512F
VBLENDMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 65 /r	AVX512VL AVX512F
VBLENDMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 65 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vblendmps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVblendmps<T, U, V>, 

VBLENDMPS instruction

Instruction	Opcode	CPUID
VBLENDMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 65 /r	AVX512VL AVX512F
VBLENDMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 65 /r	AVX512VL AVX512F
VBLENDMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 65 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vblendpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVblendpd<T, U, V, W>, 

VBLENDPD instruction

Instruction	Opcode	CPUID
VBLENDPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 0D /r ib	AVX
VBLENDPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 0D /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vblendps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVblendps<T, U, V, W>, 

VBLENDPS instruction

Instruction	Opcode	CPUID
VBLENDPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 0C /r ib	AVX
VBLENDPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 0C /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vblendvpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVblendvpd<T, U, V, W>, 

VBLENDVPD instruction

Instruction	Opcode	CPUID
VBLENDVPD xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 4B /r /is4	AVX
VBLENDVPD ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 4B /r /is4	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vblendvps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVblendvps<T, U, V, W>, 

VBLENDVPS instruction

Instruction	Opcode	CPUID
VBLENDVPS xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 4A /r /is4	AVX
VBLENDVPS ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 4A /r /is4	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vbroadcastf128<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcastf128<T, U>, 

VBROADCASTF128 instruction

Instruction	Opcode	CPUID
VBROADCASTF128 ymm1, m128	VEX.256.66.0F38.W0 1A /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcastf32x2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcastf32x2<T, U>, 

VBROADCASTF32X2 instruction

Instruction	Opcode	CPUID
VBROADCASTF32X2 ymm1 {k1}{z}, xmm2/m64	EVEX.256.66.0F38.W0 19 /r	AVX512VL AVX512DQ
VBROADCASTF32X2 zmm1 {k1}{z}, xmm2/m64	EVEX.512.66.0F38.W0 19 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcastf32x4<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcastf32x4<T, U>, 

VBROADCASTF32X4 instruction

Instruction	Opcode	CPUID
VBROADCASTF32X4 ymm1 {k1}{z}, m128	EVEX.256.66.0F38.W0 1A /r	AVX512VL AVX512F
VBROADCASTF32X4 zmm1 {k1}{z}, m128	EVEX.512.66.0F38.W0 1A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcastf32x8<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcastf32x8<T, U>, 

VBROADCASTF32X8 instruction

Instruction	Opcode	CPUID
VBROADCASTF32X8 zmm1 {k1}{z}, m256	EVEX.512.66.0F38.W0 1B /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcastf64x2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcastf64x2<T, U>, 

VBROADCASTF64X2 instruction

Instruction	Opcode	CPUID
VBROADCASTF64X2 ymm1 {k1}{z}, m128	EVEX.256.66.0F38.W1 1A /r	AVX512VL AVX512DQ
VBROADCASTF64X2 zmm1 {k1}{z}, m128	EVEX.512.66.0F38.W1 1A /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcastf64x4<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcastf64x4<T, U>, 

VBROADCASTF64X4 instruction

Instruction	Opcode	CPUID
VBROADCASTF64X4 zmm1 {k1}{z}, m256	EVEX.512.66.0F38.W1 1B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcasti128<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcasti128<T, U>, 

VBROADCASTI128 instruction

Instruction	Opcode	CPUID
VBROADCASTI128 ymm1, m128	VEX.256.66.0F38.W0 5A /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcasti32x2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcasti32x2<T, U>, 

VBROADCASTI32X2 instruction

Instruction	Opcode	CPUID
VBROADCASTI32X2 xmm1 {k1}{z}, xmm2/m64	EVEX.128.66.0F38.W0 59 /r	AVX512VL AVX512DQ
VBROADCASTI32X2 ymm1 {k1}{z}, xmm2/m64	EVEX.256.66.0F38.W0 59 /r	AVX512VL AVX512DQ
VBROADCASTI32X2 zmm1 {k1}{z}, xmm2/m64	EVEX.512.66.0F38.W0 59 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcasti32x4<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcasti32x4<T, U>, 

VBROADCASTI32X4 instruction

Instruction	Opcode	CPUID
VBROADCASTI32X4 ymm1 {k1}{z}, m128	EVEX.256.66.0F38.W0 5A /r	AVX512VL AVX512F
VBROADCASTI32X4 zmm1 {k1}{z}, m128	EVEX.512.66.0F38.W0 5A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcasti32x8<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcasti32x8<T, U>, 

VBROADCASTI32X8 instruction

Instruction	Opcode	CPUID
VBROADCASTI32X8 zmm1 {k1}{z}, m256	EVEX.512.66.0F38.W0 5B /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcasti64x2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcasti64x2<T, U>, 

VBROADCASTI64X2 instruction

Instruction	Opcode	CPUID
VBROADCASTI64X2 ymm1 {k1}{z}, m128	EVEX.256.66.0F38.W1 5A /r	AVX512VL AVX512DQ
VBROADCASTI64X2 zmm1 {k1}{z}, m128	EVEX.512.66.0F38.W1 5A /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcasti64x4<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcasti64x4<T, U>, 

VBROADCASTI64X4 instruction

Instruction	Opcode	CPUID
VBROADCASTI64X4 zmm1 {k1}{z}, m256	EVEX.512.66.0F38.W1 5B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcastsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcastsd<T, U>, 

VBROADCASTSD instruction

Instruction	Opcode	CPUID
VBROADCASTSD ymm1, m64	VEX.256.66.0F38.W0 19 /r	AVX
VBROADCASTSD ymm1, xmm2	VEX.256.66.0F38.W0 19 /r	AVX2
VBROADCASTSD ymm1 {k1}{z}, xmm2/m64	EVEX.256.66.0F38.W1 19 /r	AVX512VL AVX512F
VBROADCASTSD zmm1 {k1}{z}, xmm2/m64	EVEX.512.66.0F38.W1 19 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vbroadcastss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVbroadcastss<T, U>, 

VBROADCASTSS instruction

Instruction	Opcode	CPUID
VBROADCASTSS xmm1, m32	VEX.128.66.0F38.W0 18 /r	AVX
VBROADCASTSS xmm1, xmm2	VEX.128.66.0F38.W0 18 /r	AVX2
VBROADCASTSS ymm1, m32	VEX.256.66.0F38.W0 18 /r	AVX
VBROADCASTSS ymm1, xmm2	VEX.256.66.0F38.W0 18 /r	AVX2
VBROADCASTSS xmm1 {k1}{z}, xmm2/m32	EVEX.128.66.0F38.W0 18 /r	AVX512VL AVX512F
VBROADCASTSS ymm1 {k1}{z}, xmm2/m32	EVEX.256.66.0F38.W0 18 /r	AVX512VL AVX512F
VBROADCASTSS zmm1 {k1}{z}, xmm2/m32	EVEX.512.66.0F38.W0 18 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcmpeq_ospd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_ospd<T, U, V>, 

VCMPEQ_OSPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_osph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_osph<T, U, V>, 

VCMPEQ_OSPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_osps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_osps<T, U, V>, 

VCMPEQ_OSPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_ossd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_ossd<T, U, V>, 

VCMPEQ_OSSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_ossh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_ossh<T, U, V>, 

VCMPEQ_OSSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_osss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_osss<T, U, V>, 

VCMPEQ_OSSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_uqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_uqpd<T, U, V>, 

VCMPEQ_UQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_uqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_uqph<T, U, V>, 

VCMPEQ_UQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_uqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_uqps<T, U, V>, 

VCMPEQ_UQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_uqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_uqsd<T, U, V>, 

VCMPEQ_UQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_uqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_uqsh<T, U, V>, 

VCMPEQ_UQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_uqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_uqss<T, U, V>, 

VCMPEQ_UQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_uspd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_uspd<T, U, V>, 

VCMPEQ_USPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_usph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_usph<T, U, V>, 

VCMPEQ_USPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_usps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_usps<T, U, V>, 

VCMPEQ_USPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_ussd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_ussd<T, U, V>, 

VCMPEQ_USSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_ussh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_ussh<T, U, V>, 

VCMPEQ_USSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeq_usss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeq_usss<T, U, V>, 

VCMPEQ_USSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeqpd<T, U, V>, 

VCMPEQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeqph<T, U, V>, 

VCMPEQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeqps<T, U, V>, 

VCMPEQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeqsd<T, U, V>, 

VCMPEQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeqsh<T, U, V>, 

VCMPEQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpeqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpeqss<T, U, V>, 

VCMPEQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalse_ospd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalse_ospd<T, U, V>, 

VCMPFALSE_OSPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalse_osph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalse_osph<T, U, V>, 

VCMPFALSE_OSPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalse_osps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalse_osps<T, U, V>, 

VCMPFALSE_OSPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalse_ossd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalse_ossd<T, U, V>, 

VCMPFALSE_OSSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalse_ossh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalse_ossh<T, U, V>, 

VCMPFALSE_OSSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalse_osss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalse_osss<T, U, V>, 

VCMPFALSE_OSSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalsepd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalsepd<T, U, V>, 

VCMPFALSEPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalseph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalseph<T, U, V>, 

VCMPFALSEPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalseps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalseps<T, U, V>, 

VCMPFALSEPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalsesd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalsesd<T, U, V>, 

VCMPFALSESD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalsesh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalsesh<T, U, V>, 

VCMPFALSESH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpfalsess<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpfalsess<T, U, V>, 

VCMPFALSESS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpge_oqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpge_oqpd<T, U, V>, 

VCMPGE_OQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpge_oqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpge_oqph<T, U, V>, 

VCMPGE_OQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpge_oqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpge_oqps<T, U, V>, 

VCMPGE_OQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpge_oqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpge_oqsd<T, U, V>, 

VCMPGE_OQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpge_oqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpge_oqsh<T, U, V>, 

VCMPGE_OQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpge_oqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpge_oqss<T, U, V>, 

VCMPGE_OQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgepd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgepd<T, U, V>, 

VCMPGEPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgeph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgeph<T, U, V>, 

VCMPGEPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgeps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgeps<T, U, V>, 

VCMPGEPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgesd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgesd<T, U, V>, 

VCMPGESD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgesh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgesh<T, U, V>, 

VCMPGESH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgess<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgess<T, U, V>, 

VCMPGESS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgt_oqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgt_oqpd<T, U, V>, 

VCMPGT_OQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgt_oqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgt_oqph<T, U, V>, 

VCMPGT_OQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgt_oqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgt_oqps<T, U, V>, 

VCMPGT_OQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgt_oqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgt_oqsd<T, U, V>, 

VCMPGT_OQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgt_oqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgt_oqsh<T, U, V>, 

VCMPGT_OQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgt_oqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgt_oqss<T, U, V>, 

VCMPGT_OQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgtpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgtpd<T, U, V>, 

VCMPGTPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgtph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgtph<T, U, V>, 

VCMPGTPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgtps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgtps<T, U, V>, 

VCMPGTPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgtsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgtsd<T, U, V>, 

VCMPGTSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgtsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgtsh<T, U, V>, 

VCMPGTSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpgtss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpgtss<T, U, V>, 

VCMPGTSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmple_oqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmple_oqpd<T, U, V>, 

VCMPLE_OQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmple_oqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmple_oqph<T, U, V>, 

VCMPLE_OQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmple_oqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmple_oqps<T, U, V>, 

VCMPLE_OQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmple_oqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmple_oqsd<T, U, V>, 

VCMPLE_OQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmple_oqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmple_oqsh<T, U, V>, 

VCMPLE_OQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmple_oqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmple_oqss<T, U, V>, 

VCMPLE_OQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmplepd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmplepd<T, U, V>, 

VCMPLEPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpleph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpleph<T, U, V>, 

VCMPLEPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpleps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpleps<T, U, V>, 

VCMPLEPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmplesd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmplesd<T, U, V>, 

VCMPLESD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmplesh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmplesh<T, U, V>, 

VCMPLESH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpless<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpless<T, U, V>, 

VCMPLESS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmplt_oqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmplt_oqpd<T, U, V>, 

VCMPLT_OQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmplt_oqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmplt_oqph<T, U, V>, 

VCMPLT_OQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmplt_oqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmplt_oqps<T, U, V>, 

VCMPLT_OQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmplt_oqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmplt_oqsd<T, U, V>, 

VCMPLT_OQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmplt_oqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmplt_oqsh<T, U, V>, 

VCMPLT_OQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmplt_oqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmplt_oqss<T, U, V>, 

VCMPLT_OQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpltpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpltpd<T, U, V>, 

VCMPLTPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpltph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpltph<T, U, V>, 

VCMPLTPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpltps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpltps<T, U, V>, 

VCMPLTPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpltsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpltsd<T, U, V>, 

VCMPLTSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpltsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpltsh<T, U, V>, 

VCMPLTSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpltss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpltss<T, U, V>, 

VCMPLTSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_oqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_oqpd<T, U, V>, 

VCMPNEQ_OQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_oqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_oqph<T, U, V>, 

VCMPNEQ_OQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_oqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_oqps<T, U, V>, 

VCMPNEQ_OQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_oqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_oqsd<T, U, V>, 

VCMPNEQ_OQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_oqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_oqsh<T, U, V>, 

VCMPNEQ_OQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_oqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_oqss<T, U, V>, 

VCMPNEQ_OQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_ospd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_ospd<T, U, V>, 

VCMPNEQ_OSPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_osph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_osph<T, U, V>, 

VCMPNEQ_OSPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_osps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_osps<T, U, V>, 

VCMPNEQ_OSPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_ossd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_ossd<T, U, V>, 

VCMPNEQ_OSSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_ossh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_ossh<T, U, V>, 

VCMPNEQ_OSSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_osss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_osss<T, U, V>, 

VCMPNEQ_OSSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_uspd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_uspd<T, U, V>, 

VCMPNEQ_USPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_usph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_usph<T, U, V>, 

VCMPNEQ_USPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_usps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_usps<T, U, V>, 

VCMPNEQ_USPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_ussd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_ussd<T, U, V>, 

VCMPNEQ_USSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_ussh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_ussh<T, U, V>, 

VCMPNEQ_USSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneq_usss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneq_usss<T, U, V>, 

VCMPNEQ_USSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneqpd<T, U, V>, 

VCMPNEQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneqph<T, U, V>, 

VCMPNEQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneqps<T, U, V>, 

VCMPNEQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneqsd<T, U, V>, 

VCMPNEQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneqsh<T, U, V>, 

VCMPNEQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpneqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpneqss<T, U, V>, 

VCMPNEQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnge_uqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnge_uqpd<T, U, V>, 

VCMPNGE_UQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnge_uqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnge_uqph<T, U, V>, 

VCMPNGE_UQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnge_uqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnge_uqps<T, U, V>, 

VCMPNGE_UQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnge_uqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnge_uqsd<T, U, V>, 

VCMPNGE_UQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnge_uqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnge_uqsh<T, U, V>, 

VCMPNGE_UQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnge_uqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnge_uqss<T, U, V>, 

VCMPNGE_UQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngepd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngepd<T, U, V>, 

VCMPNGEPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngeph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngeph<T, U, V>, 

VCMPNGEPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngeps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngeps<T, U, V>, 

VCMPNGEPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngesd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngesd<T, U, V>, 

VCMPNGESD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngesh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngesh<T, U, V>, 

VCMPNGESH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngess<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngess<T, U, V>, 

VCMPNGESS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngt_uqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngt_uqpd<T, U, V>, 

VCMPNGT_UQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngt_uqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngt_uqph<T, U, V>, 

VCMPNGT_UQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngt_uqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngt_uqps<T, U, V>, 

VCMPNGT_UQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngt_uqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngt_uqsd<T, U, V>, 

VCMPNGT_UQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngt_uqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngt_uqsh<T, U, V>, 

VCMPNGT_UQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngt_uqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngt_uqss<T, U, V>, 

VCMPNGT_UQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngtpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngtpd<T, U, V>, 

VCMPNGTPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngtph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngtph<T, U, V>, 

VCMPNGTPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngtps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngtps<T, U, V>, 

VCMPNGTPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngtsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngtsd<T, U, V>, 

VCMPNGTSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngtsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngtsh<T, U, V>, 

VCMPNGTSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpngtss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpngtss<T, U, V>, 

VCMPNGTSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnle_uqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnle_uqpd<T, U, V>, 

VCMPNLE_UQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnle_uqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnle_uqph<T, U, V>, 

VCMPNLE_UQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnle_uqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnle_uqps<T, U, V>, 

VCMPNLE_UQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnle_uqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnle_uqsd<T, U, V>, 

VCMPNLE_UQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnle_uqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnle_uqsh<T, U, V>, 

VCMPNLE_UQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnle_uqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnle_uqss<T, U, V>, 

VCMPNLE_UQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnlepd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnlepd<T, U, V>, 

VCMPNLEPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnleph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnleph<T, U, V>, 

VCMPNLEPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnleps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnleps<T, U, V>, 

VCMPNLEPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnlesd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnlesd<T, U, V>, 

VCMPNLESD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnlesh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnlesh<T, U, V>, 

VCMPNLESH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnless<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnless<T, U, V>, 

VCMPNLESS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnlt_uqpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnlt_uqpd<T, U, V>, 

VCMPNLT_UQPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnlt_uqph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnlt_uqph<T, U, V>, 

VCMPNLT_UQPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnlt_uqps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnlt_uqps<T, U, V>, 

VCMPNLT_UQPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnlt_uqsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnlt_uqsd<T, U, V>, 

VCMPNLT_UQSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnlt_uqsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnlt_uqsh<T, U, V>, 

VCMPNLT_UQSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnlt_uqss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnlt_uqss<T, U, V>, 

VCMPNLT_UQSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnltpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnltpd<T, U, V>, 

VCMPNLTPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnltph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnltph<T, U, V>, 

VCMPNLTPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnltps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnltps<T, U, V>, 

VCMPNLTPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnltsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnltsd<T, U, V>, 

VCMPNLTSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnltsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnltsh<T, U, V>, 

VCMPNLTSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpnltss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpnltss<T, U, V>, 

VCMPNLTSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpord_spd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpord_spd<T, U, V>, 

VCMPORD_SPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpord_sph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpord_sph<T, U, V>, 

VCMPORD_SPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpord_sps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpord_sps<T, U, V>, 

VCMPORD_SPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpord_ssd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpord_ssd<T, U, V>, 

VCMPORD_SSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpord_ssh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpord_ssh<T, U, V>, 

VCMPORD_SSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpord_sss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpord_sss<T, U, V>, 

VCMPORD_SSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpordpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpordpd<T, U, V>, 

VCMPORDPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpordph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpordph<T, U, V>, 

VCMPORDPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpordps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpordps<T, U, V>, 

VCMPORDPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpordsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpordsd<T, U, V>, 

VCMPORDSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpordsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpordsh<T, U, V>, 

VCMPORDSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpordss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpordss<T, U, V>, 

VCMPORDSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmppd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVcmppd<T, U, V, W>, 

VCMPPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vcmpph<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpph<T, U, V, W>, 

VCMPPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vcmpps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpps<T, U, V, W>, 

VCMPPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vcmpsd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpsd<T, U, V, W>, 

VCMPSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vcmpsh<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpsh<T, U, V, W>, 

VCMPSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vcmpss<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpss<T, U, V, W>, 

VCMPSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vcmptrue_uspd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptrue_uspd<T, U, V>, 

VCMPTRUE_USPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptrue_usph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptrue_usph<T, U, V>, 

VCMPTRUE_USPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptrue_usps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptrue_usps<T, U, V>, 

VCMPTRUE_USPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptrue_ussd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptrue_ussd<T, U, V>, 

VCMPTRUE_USSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptrue_ussh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptrue_ussh<T, U, V>, 

VCMPTRUE_USSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptrue_usss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptrue_usss<T, U, V>, 

VCMPTRUE_USSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptruepd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptruepd<T, U, V>, 

VCMPTRUEPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptrueph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptrueph<T, U, V>, 

VCMPTRUEPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptrueps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptrueps<T, U, V>, 

VCMPTRUEPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptruesd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptruesd<T, U, V>, 

VCMPTRUESD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptruesh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptruesh<T, U, V>, 

VCMPTRUESH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmptruess<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmptruess<T, U, V>, 

VCMPTRUESS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunord_spd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunord_spd<T, U, V>, 

VCMPUNORD_SPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunord_sph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunord_sph<T, U, V>, 

VCMPUNORD_SPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunord_sps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunord_sps<T, U, V>, 

VCMPUNORD_SPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunord_ssd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunord_ssd<T, U, V>, 

VCMPUNORD_SSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunord_ssh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunord_ssh<T, U, V>, 

VCMPUNORD_SSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunord_sss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunord_sss<T, U, V>, 

VCMPUNORD_SSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunordpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunordpd<T, U, V>, 

VCMPUNORDPD instruction

Instruction	Opcode	CPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C2 /r ib	AVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C2 /r ib	AVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C2 /r ib	AVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunordph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunordph<T, U, V>, 

VCMPUNORDPH instruction

Instruction	Opcode	CPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8	EVEX.128.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8	EVEX.256.0F3A.W0 C2 /r ib	AVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunordps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunordps<T, U, V>, 

VCMPUNORDPS instruction

Instruction	Opcode	CPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C2 /r ib	AVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C2 /r ib	AVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C2 /r ib	AVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunordsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunordsd<T, U, V>, 

VCMPUNORDSD instruction

Instruction	Opcode	CPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.F2.0F.WIG C2 /r ib	AVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.F2.0F.W1 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunordsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunordsh<T, U, V>, 

VCMPUNORDSH instruction

Instruction	Opcode	CPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.F3.0F3A.W0 C2 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcmpunordss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcmpunordss<T, U, V>, 

VCMPUNORDSS instruction

Instruction	Opcode	CPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.F3.0F.WIG C2 /r ib	AVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.F3.0F.W0 C2 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcomisd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcomisd<T, U>, 

VCOMISD instruction

Instruction	Opcode	CPUID
VCOMISD xmm1, xmm2/m64	VEX.LIG.66.0F.WIG 2F /r	AVX
VCOMISD xmm1, xmm2/m64{sae}	EVEX.LIG.66.0F.W1 2F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcomish<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcomish<T, U>, 

VCOMISH instruction

Instruction	Opcode	CPUID
VCOMISH xmm1, xmm2/m16{sae}	EVEX.LIG.MAP5.W0 2F /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcomiss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcomiss<T, U>, 

VCOMISS instruction

Instruction	Opcode	CPUID
VCOMISS xmm1, xmm2/m32	VEX.LIG.0F.WIG 2F /r	AVX
VCOMISS xmm1, xmm2/m32{sae}	EVEX.LIG.0F.W0 2F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcompresspd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcompresspd<T, U>, 

VCOMPRESSPD instruction

Instruction	Opcode	CPUID
VCOMPRESSPD xmm1/m128 {k1}{z}, xmm2	EVEX.128.66.0F38.W1 8A /r	AVX512VL AVX512F
VCOMPRESSPD ymm1/m256 {k1}{z}, ymm2	EVEX.256.66.0F38.W1 8A /r	AVX512VL AVX512F
VCOMPRESSPD zmm1/m512 {k1}{z}, zmm2	EVEX.512.66.0F38.W1 8A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcompressps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcompressps<T, U>, 

VCOMPRESSPS instruction

Instruction	Opcode	CPUID
VCOMPRESSPS xmm1/m128 {k1}{z}, xmm2	EVEX.128.66.0F38.W0 8A /r	AVX512VL AVX512F
VCOMPRESSPS ymm1/m256 {k1}{z}, ymm2	EVEX.256.66.0F38.W0 8A /r	AVX512VL AVX512F
VCOMPRESSPS zmm1/m512 {k1}{z}, zmm2	EVEX.512.66.0F38.W0 8A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtdq2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtdq2pd<T, U>, 

VCVTDQ2PD instruction

Instruction	Opcode	CPUID
VCVTDQ2PD xmm1, xmm2/m64	VEX.128.F3.0F.WIG E6 /r	AVX
VCVTDQ2PD ymm1, xmm2/m128	VEX.256.F3.0F.WIG E6 /r	AVX
VCVTDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst	EVEX.128.F3.0F.W0 E6 /r	AVX512VL AVX512F
VCVTDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.256.F3.0F.W0 E6 /r	AVX512VL AVX512F
VCVTDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{er}	EVEX.512.F3.0F.W0 E6 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtdq2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtdq2ph<T, U>, 

VCVTDQ2PH instruction

Instruction	Opcode	CPUID
VCVTDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.MAP5.W0 5B /r	AVX512VL AVX512-FP16
VCVTDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.MAP5.W0 5B /r	AVX512VL AVX512-FP16
VCVTDQ2PH ymm1 {k1}{z}, zmm2/m512/m32bcst{er}	EVEX.512.MAP5.W0 5B /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtdq2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtdq2phx<T, U>, 

VCVTDQ2PHX instruction

Instruction	Opcode	CPUID
VCVTDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.MAP5.W0 5B /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtdq2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtdq2phy<T, U>, 

VCVTDQ2PHY instruction

Instruction	Opcode	CPUID
VCVTDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.MAP5.W0 5B /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtdq2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtdq2ps<T, U>, 

VCVTDQ2PS instruction

Instruction	Opcode	CPUID
VCVTDQ2PS xmm1, xmm2/m128	VEX.128.0F.WIG 5B /r	AVX
VCVTDQ2PS ymm1, ymm2/m256	VEX.256.0F.WIG 5B /r	AVX
VCVTDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.0F.W0 5B /r	AVX512VL AVX512F
VCVTDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.0F.W0 5B /r	AVX512VL AVX512F
VCVTDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}	EVEX.512.0F.W0 5B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtne2ps2bf16<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtne2ps2bf16<T, U, V>, 

VCVTNE2PS2BF16 instruction

Instruction	Opcode	CPUID
VCVTNE2PS2BF16 xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.F2.0F38.W0 72 /r	AVX512VL AVX512_BF16
VCVTNE2PS2BF16 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.F2.0F38.W0 72 /r	AVX512VL AVX512_BF16
VCVTNE2PS2BF16 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.F2.0F38.W0 72 /r	AVX512F AVX512_BF16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtneps2bf16<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtneps2bf16<T, U>, 

VCVTNEPS2BF16 instruction

Instruction	Opcode	CPUID
VCVTNEPS2BF16 xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.F3.0F38.W0 72 /r	AVX512VL AVX512_BF16
VCVTNEPS2BF16 xmm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.F3.0F38.W0 72 /r	AVX512VL AVX512_BF16
VCVTNEPS2BF16 ymm1 {k1}{z}, zmm2/m512/m32bcst	EVEX.512.F3.0F38.W0 72 /r	AVX512F AVX512_BF16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtneps2bf16x<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtneps2bf16x<T, U>, 

VCVTNEPS2BF16X instruction

Instruction	Opcode	CPUID
VCVTNEPS2BF16 xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.F3.0F38.W0 72 /r	AVX512VL AVX512_BF16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtneps2bf16y<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtneps2bf16y<T, U>, 

VCVTNEPS2BF16Y instruction

Instruction	Opcode	CPUID
VCVTNEPS2BF16 xmm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.F3.0F38.W0 72 /r	AVX512VL AVX512_BF16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2dq<T, U>, 

VCVTPD2DQ instruction

Instruction	Opcode	CPUID
VCVTPD2DQ xmm1, xmm2/m128	VEX.128.F2.0F.WIG E6 /r	AVX
VCVTPD2DQ xmm1, ymm2/m256	VEX.256.F2.0F.WIG E6 /r	AVX
VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.F2.0F.W1 E6 /r	AVX512VL AVX512F
VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.F2.0F.W1 E6 /r	AVX512VL AVX512F
VCVTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.F2.0F.W1 E6 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2dqx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2dqx<T, U>, 

VCVTPD2DQX instruction

Instruction	Opcode	CPUID
VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.F2.0F.W1 E6 /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2dqy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2dqy<T, U>, 

VCVTPD2DQY instruction

Instruction	Opcode	CPUID
VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.F2.0F.W1 E6 /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2ph<T, U>, 

VCVTPD2PH instruction

Instruction	Opcode	CPUID
VCVTPD2PH xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.MAP5.W1 5A /r	AVX512VL AVX512-FP16
VCVTPD2PH xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.MAP5.W1 5A /r	AVX512VL AVX512-FP16
VCVTPD2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.66.MAP5.W1 5A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2phx<T, U>, 

VCVTPD2PHX instruction

Instruction	Opcode	CPUID
VCVTPD2PH xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.MAP5.W1 5A /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2phy<T, U>, 

VCVTPD2PHY instruction

Instruction	Opcode	CPUID
VCVTPD2PH xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.MAP5.W1 5A /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2phz<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2phz<T, U>, 

VCVTPD2PHZ instruction

Instruction	Opcode	CPUID
VCVTPD2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.66.MAP5.W1 5A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2ps<T, U>, 

VCVTPD2PS instruction

Instruction	Opcode	CPUID
VCVTPD2PS xmm1, xmm2/m128	VEX.128.66.0F.WIG 5A /r	AVX
VCVTPD2PS xmm1, ymm2/m256	VEX.256.66.0F.WIG 5A /r	AVX
VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F.W1 5A /r	AVX512VL AVX512F
VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F.W1 5A /r	AVX512VL AVX512F
VCVTPD2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.66.0F.W1 5A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2psx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2psx<T, U>, 

VCVTPD2PSX instruction

Instruction	Opcode	CPUID
VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F.W1 5A /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2psy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2psy<T, U>, 

VCVTPD2PSY instruction

Instruction	Opcode	CPUID
VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F.W1 5A /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2qq<T, U>, 

VCVTPD2QQ instruction

Instruction	Opcode	CPUID
VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F.W1 7B /r	AVX512VL AVX512DQ
VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F.W1 7B /r	AVX512VL AVX512DQ
VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.66.0F.W1 7B /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2udq<T, U>, 

VCVTPD2UDQ instruction

Instruction	Opcode	CPUID
VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.0F.W1 79 /r	AVX512VL AVX512F
VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.0F.W1 79 /r	AVX512VL AVX512F
VCVTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.0F.W1 79 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2udqx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2udqx<T, U>, 

VCVTPD2UDQX instruction

Instruction	Opcode	CPUID
VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.0F.W1 79 /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2udqy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2udqy<T, U>, 

VCVTPD2UDQY instruction

Instruction	Opcode	CPUID
VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.0F.W1 79 /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtpd2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtpd2uqq<T, U>, 

VCVTPD2UQQ instruction

Instruction	Opcode	CPUID
VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F.W1 79 /r	AVX512VL AVX512DQ
VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F.W1 79 /r	AVX512VL AVX512DQ
VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.66.0F.W1 79 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtph2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtph2dq<T, U>, 

VCVTPH2DQ instruction

Instruction	Opcode	CPUID
VCVTPH2DQ xmm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.128.66.MAP5.W0 5B /r	AVX512VL AVX512-FP16
VCVTPH2DQ ymm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.256.66.MAP5.W0 5B /r	AVX512VL AVX512-FP16
VCVTPH2DQ zmm1 {k1}{z}, ymm2/m256/m16bcst{er}	EVEX.512.66.MAP5.W0 5B /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtph2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtph2pd<T, U>, 

VCVTPH2PD instruction

Instruction	Opcode	CPUID
VCVTPH2PD xmm1 {k1}{z}, xmm2/m32/m16bcst	EVEX.128.MAP5.W0 5A /r	AVX512VL AVX512-FP16
VCVTPH2PD ymm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.256.MAP5.W0 5A /r	AVX512VL AVX512-FP16
VCVTPH2PD zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}	EVEX.512.MAP5.W0 5A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtph2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtph2ps<T, U>, 

VCVTPH2PS instruction

Instruction	Opcode	CPUID
VCVTPH2PS xmm1, xmm2/m64	VEX.128.66.0F38.W0 13 /r	F16C
VCVTPH2PS ymm1, xmm2/m128	VEX.256.66.0F38.W0 13 /r	F16C
VCVTPH2PS xmm1 {k1}{z}, xmm2/m64	EVEX.128.66.0F38.W0 13 /r	AVX512VL AVX512F
VCVTPH2PS ymm1 {k1}{z}, xmm2/m128	EVEX.256.66.0F38.W0 13 /r	AVX512VL AVX512F
VCVTPH2PS zmm1 {k1}{z}, ymm2/m256{sae}	EVEX.512.66.0F38.W0 13 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtph2psx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtph2psx<T, U>, 

VCVTPH2PSX instruction

Instruction	Opcode	CPUID
VCVTPH2PSX xmm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.128.66.MAP6.W0 13 /r	AVX512VL AVX512-FP16
VCVTPH2PSX ymm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.256.66.MAP6.W0 13 /r	AVX512VL AVX512-FP16
VCVTPH2PSX zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}	EVEX.512.66.MAP6.W0 13 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtph2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtph2qq<T, U>, 

VCVTPH2QQ instruction

Instruction	Opcode	CPUID
VCVTPH2QQ xmm1 {k1}{z}, xmm2/m32/m16bcst	EVEX.128.66.MAP5.W0 7B /r	AVX512VL AVX512-FP16
VCVTPH2QQ ymm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.256.66.MAP5.W0 7B /r	AVX512VL AVX512-FP16
VCVTPH2QQ zmm1 {k1}{z}, xmm2/m128/m16bcst{er}	EVEX.512.66.MAP5.W0 7B /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtph2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtph2udq<T, U>, 

VCVTPH2UDQ instruction

Instruction	Opcode	CPUID
VCVTPH2UDQ xmm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.128.MAP5.W0 79 /r	AVX512VL AVX512-FP16
VCVTPH2UDQ ymm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.256.MAP5.W0 79 /r	AVX512VL AVX512-FP16
VCVTPH2UDQ zmm1 {k1}{z}, ymm2/m256/m16bcst{er}	EVEX.512.MAP5.W0 79 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtph2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtph2uqq<T, U>, 

VCVTPH2UQQ instruction

Instruction	Opcode	CPUID
VCVTPH2UQQ xmm1 {k1}{z}, xmm2/m32/m16bcst	EVEX.128.66.MAP5.W0 79 /r	AVX512VL AVX512-FP16
VCVTPH2UQQ ymm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.256.66.MAP5.W0 79 /r	AVX512VL AVX512-FP16
VCVTPH2UQQ zmm1 {k1}{z}, xmm2/m128/m16bcst{er}	EVEX.512.66.MAP5.W0 79 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtph2uw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtph2uw<T, U>, 

VCVTPH2UW instruction

Instruction	Opcode	CPUID
VCVTPH2UW xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.MAP5.W0 7D /r	AVX512VL AVX512-FP16
VCVTPH2UW ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.MAP5.W0 7D /r	AVX512VL AVX512-FP16
VCVTPH2UW zmm1 {k1}{z}, zmm2/m512/m16bcst{er}	EVEX.512.MAP5.W0 7D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtph2w<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtph2w<T, U>, 

VCVTPH2W instruction

Instruction	Opcode	CPUID
VCVTPH2W xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.66.MAP5.W0 7D /r	AVX512VL AVX512-FP16
VCVTPH2W ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.66.MAP5.W0 7D /r	AVX512VL AVX512-FP16
VCVTPH2W zmm1 {k1}{z}, zmm2/m512/m16bcst{er}	EVEX.512.66.MAP5.W0 7D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtps2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtps2dq<T, U>, 

VCVTPS2DQ instruction

Instruction	Opcode	CPUID
VCVTPS2DQ xmm1, xmm2/m128	VEX.128.66.0F.WIG 5B /r	AVX
VCVTPS2DQ ymm1, ymm2/m256	VEX.256.66.0F.WIG 5B /r	AVX
VCVTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.0F.W0 5B /r	AVX512VL AVX512F
VCVTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.0F.W0 5B /r	AVX512VL AVX512F
VCVTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er}	EVEX.512.66.0F.W0 5B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtps2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtps2pd<T, U>, 

VCVTPS2PD instruction

Instruction	Opcode	CPUID
VCVTPS2PD xmm1, xmm2/m64	VEX.128.0F.WIG 5A /r	AVX
VCVTPS2PD ymm1, xmm2/m128	VEX.256.0F.WIG 5A /r	AVX
VCVTPS2PD xmm1 {k1}{z}, xmm2/m64/m32bcst	EVEX.128.0F.W0 5A /r	AVX512VL AVX512F
VCVTPS2PD ymm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.256.0F.W0 5A /r	AVX512VL AVX512F
VCVTPS2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}	EVEX.512.0F.W0 5A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtps2ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtps2ph<T, U, V>, 

VCVTPS2PH instruction

Instruction	Opcode	CPUID
VCVTPS2PH xmm1/m64, xmm2, imm8	VEX.128.66.0F3A.W0 1D /r ib	F16C
VCVTPS2PH xmm1/m128, ymm2, imm8	VEX.256.66.0F3A.W0 1D /r ib	F16C
VCVTPS2PH xmm1/m64 {k1}{z}, xmm2, imm8	EVEX.128.66.0F3A.W0 1D /r ib	AVX512VL AVX512F
VCVTPS2PH xmm1/m128 {k1}{z}, ymm2, imm8	EVEX.256.66.0F3A.W0 1D /r ib	AVX512VL AVX512F
VCVTPS2PH ymm1/m256 {k1}{z}, zmm2{sae}, imm8	EVEX.512.66.0F3A.W0 1D /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtps2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtps2phx<T, U>, 

VCVTPS2PHX instruction

Instruction	Opcode	CPUID
VCVTPS2PHX xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.MAP5.W0 1D /r	AVX512VL AVX512-FP16
VCVTPS2PHX xmm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.MAP5.W0 1D /r	AVX512VL AVX512-FP16
VCVTPS2PHX ymm1 {k1}{z}, zmm2/m512/m32bcst{er}	EVEX.512.66.MAP5.W0 1D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtps2phxx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtps2phxx<T, U>, 

VCVTPS2PHXX instruction

Instruction	Opcode	CPUID
VCVTPS2PHX xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.MAP5.W0 1D /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtps2phxy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtps2phxy<T, U>, 

VCVTPS2PHXY instruction

Instruction	Opcode	CPUID
VCVTPS2PHX xmm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.MAP5.W0 1D /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtps2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtps2qq<T, U>, 

VCVTPS2QQ instruction

Instruction	Opcode	CPUID
VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst	EVEX.128.66.0F.W0 7B /r	AVX512VL AVX512DQ
VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.256.66.0F.W0 7B /r	AVX512VL AVX512DQ
VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er}	EVEX.512.66.0F.W0 7B /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtps2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtps2udq<T, U>, 

VCVTPS2UDQ instruction

Instruction	Opcode	CPUID
VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.0F.W0 79 /r	AVX512VL AVX512F
VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.0F.W0 79 /r	AVX512VL AVX512F
VCVTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er}	EVEX.512.0F.W0 79 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtps2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtps2uqq<T, U>, 

VCVTPS2UQQ instruction

Instruction	Opcode	CPUID
VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst	EVEX.128.66.0F.W0 79 /r	AVX512VL AVX512DQ
VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.256.66.0F.W0 79 /r	AVX512VL AVX512DQ
VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er}	EVEX.512.66.0F.W0 79 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtqq2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtqq2pd<T, U>, 

VCVTQQ2PD instruction

Instruction	Opcode	CPUID
VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.F3.0F.W1 E6 /r	AVX512VL AVX512DQ
VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.F3.0F.W1 E6 /r	AVX512VL AVX512DQ
VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.F3.0F.W1 E6 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtqq2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtqq2ph<T, U>, 

VCVTQQ2PH instruction

Instruction	Opcode	CPUID
VCVTQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.MAP5.W1 5B /r	AVX512VL AVX512-FP16
VCVTQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.MAP5.W1 5B /r	AVX512VL AVX512-FP16
VCVTQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.MAP5.W1 5B /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtqq2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtqq2phx<T, U>, 

VCVTQQ2PHX instruction

Instruction	Opcode	CPUID
VCVTQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.MAP5.W1 5B /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtqq2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtqq2phy<T, U>, 

VCVTQQ2PHY instruction

Instruction	Opcode	CPUID
VCVTQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.MAP5.W1 5B /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtqq2phz<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtqq2phz<T, U>, 

VCVTQQ2PHZ instruction

Instruction	Opcode	CPUID
VCVTQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.MAP5.W1 5B /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtqq2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtqq2ps<T, U>, 

VCVTQQ2PS instruction

Instruction	Opcode	CPUID
VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.0F.W1 5B /r	AVX512VL AVX512DQ
VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.0F.W1 5B /r	AVX512VL AVX512DQ
VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.0F.W1 5B /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtqq2psx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtqq2psx<T, U>, 

VCVTQQ2PSX instruction

Instruction	Opcode	CPUID
VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.0F.W1 5B /r	AVX512VL AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtqq2psy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtqq2psy<T, U>, 

VCVTQQ2PSY instruction

Instruction	Opcode	CPUID
VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.0F.W1 5B /r	AVX512VL AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtsd2sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsd2sh<T, U, V>, 

VCVTSD2SH instruction

Instruction	Opcode	CPUID
VCVTSD2SH xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.F2.MAP5.W1 5A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtsd2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsd2si<T, U>, 

VCVTSD2SI instruction

Instruction	Opcode	CPUID
VCVTSD2SI r32, xmm1/m64	VEX.LIG.F2.0F.W0 2D /r	AVX
VCVTSD2SI r64, xmm1/m64	VEX.LIG.F2.0F.W1 2D /r	AVX
VCVTSD2SI r32, xmm1/m64{er}	EVEX.LIG.F2.0F.W0 2D /r	AVX512F
VCVTSD2SI r64, xmm1/m64{er}	EVEX.LIG.F2.0F.W1 2D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtsd2ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsd2ss<T, U, V>, 

VCVTSD2SS instruction

Instruction	Opcode	CPUID
VCVTSD2SS xmm1, xmm2, xmm3/m64	VEX.LIG.F2.0F.WIG 5A /r	AVX
VCVTSD2SS xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.F2.0F.W1 5A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtsd2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsd2usi<T, U>, 

VCVTSD2USI instruction

Instruction	Opcode	CPUID
VCVTSD2USI r32, xmm1/m64{er}	EVEX.LIG.F2.0F.W0 79 /r	AVX512F
VCVTSD2USI r64, xmm1/m64{er}	EVEX.LIG.F2.0F.W1 79 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtsh2sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsh2sd<T, U, V>, 

VCVTSH2SD instruction

Instruction	Opcode	CPUID
VCVTSH2SD xmm1 {k1}{z}, xmm2, xmm3/m16{sae}	EVEX.LIG.F3.MAP5.W0 5A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtsh2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsh2si<T, U>, 

VCVTSH2SI instruction

Instruction	Opcode	CPUID
VCVTSH2SI r32, xmm1/m16{er}	EVEX.LIG.F3.MAP5.W0 2D /r	AVX512-FP16
VCVTSH2SI r64, xmm1/m16{er}	EVEX.LIG.F3.MAP5.W1 2D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtsh2ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsh2ss<T, U, V>, 

VCVTSH2SS instruction

Instruction	Opcode	CPUID
VCVTSH2SS xmm1 {k1}{z}, xmm2, xmm3/m16{sae}	EVEX.LIG.MAP6.W0 13 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtsh2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsh2usi<T, U>, 

VCVTSH2USI instruction

Instruction	Opcode	CPUID
VCVTSH2USI r32, xmm1/m16{er}	EVEX.LIG.F3.MAP5.W0 79 /r	AVX512-FP16
VCVTSH2USI r64, xmm1/m16{er}	EVEX.LIG.F3.MAP5.W1 79 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtsi2sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsi2sd<T, U, V>, 

VCVTSI2SD instruction

Instruction	Opcode	CPUID
VCVTSI2SD xmm1, xmm2, r/m32	VEX.LIG.F2.0F.W0 2A /r	AVX
VCVTSI2SD xmm1, xmm2, r/m64	VEX.LIG.F2.0F.W1 2A /r	AVX
VCVTSI2SD xmm1, xmm2, r/m32{er}	EVEX.LIG.F2.0F.W0 2A /r	AVX512F
VCVTSI2SD xmm1, xmm2, r/m64{er}	EVEX.LIG.F2.0F.W1 2A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtsi2sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsi2sh<T, U, V>, 

VCVTSI2SH instruction

Instruction	Opcode	CPUID
VCVTSI2SH xmm1, xmm2, r/m32{er}	EVEX.LIG.F3.MAP5.W0 2A /r	AVX512-FP16
VCVTSI2SH xmm1, xmm2, r/m64{er}	EVEX.LIG.F3.MAP5.W1 2A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtsi2ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtsi2ss<T, U, V>, 

VCVTSI2SS instruction

Instruction	Opcode	CPUID
VCVTSI2SS xmm1, xmm2, r/m32	VEX.LIG.F3.0F.W0 2A /r	AVX
VCVTSI2SS xmm1, xmm2, r/m64	VEX.LIG.F3.0F.W1 2A /r	AVX
VCVTSI2SS xmm1, xmm2, r/m32{er}	EVEX.LIG.F3.0F.W0 2A /r	AVX512F
VCVTSI2SS xmm1, xmm2, r/m64{er}	EVEX.LIG.F3.0F.W1 2A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtss2sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtss2sd<T, U, V>, 

VCVTSS2SD instruction

Instruction	Opcode	CPUID
VCVTSS2SD xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 5A /r	AVX
VCVTSS2SD xmm1 {k1}{z}, xmm2, xmm3/m32{sae}	EVEX.LIG.F3.0F.W0 5A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtss2sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtss2sh<T, U, V>, 

VCVTSS2SH instruction

Instruction	Opcode	CPUID
VCVTSS2SH xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.MAP5.W0 1D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtss2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtss2si<T, U>, 

VCVTSS2SI instruction

Instruction	Opcode	CPUID
VCVTSS2SI r32, xmm1/m32	VEX.LIG.F3.0F.W0 2D /r	AVX
VCVTSS2SI r64, xmm1/m32	VEX.LIG.F3.0F.W1 2D /r	AVX
VCVTSS2SI r32, xmm1/m32{er}	EVEX.LIG.F3.0F.W0 2D /r	AVX512F
VCVTSS2SI r64, xmm1/m32{er}	EVEX.LIG.F3.0F.W1 2D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtss2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtss2usi<T, U>, 

VCVTSS2USI instruction

Instruction	Opcode	CPUID
VCVTSS2USI r32, xmm1/m32{er}	EVEX.LIG.F3.0F.W0 79 /r	AVX512F
VCVTSS2USI r64, xmm1/m32{er}	EVEX.LIG.F3.0F.W1 79 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttpd2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttpd2dq<T, U>, 

VCVTTPD2DQ instruction

Instruction	Opcode	CPUID
VCVTTPD2DQ xmm1, xmm2/m128	VEX.128.66.0F.WIG E6 /r	AVX
VCVTTPD2DQ xmm1, ymm2/m256	VEX.256.66.0F.WIG E6 /r	AVX
VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F.W1 E6 /r	AVX512VL AVX512F
VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F.W1 E6 /r	AVX512VL AVX512F
VCVTTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae}	EVEX.512.66.0F.W1 E6 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttpd2dqx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttpd2dqx<T, U>, 

VCVTTPD2DQX instruction

Instruction	Opcode	CPUID
VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F.W1 E6 /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttpd2dqy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttpd2dqy<T, U>, 

VCVTTPD2DQY instruction

Instruction	Opcode	CPUID
VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F.W1 E6 /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttpd2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttpd2qq<T, U>, 

VCVTTPD2QQ instruction

Instruction	Opcode	CPUID
VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F.W1 7A /r	AVX512VL AVX512DQ
VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F.W1 7A /r	AVX512VL AVX512DQ
VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}	EVEX.512.66.0F.W1 7A /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttpd2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttpd2udq<T, U>, 

VCVTTPD2UDQ instruction

Instruction	Opcode	CPUID
VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.0F.W1 78 /r	AVX512VL AVX512F
VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.0F.W1 78 /r	AVX512VL AVX512F
VCVTTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae}	EVEX.512.0F.W1 78 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttpd2udqx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttpd2udqx<T, U>, 

VCVTTPD2UDQX instruction

Instruction	Opcode	CPUID
VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.0F.W1 78 /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttpd2udqy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttpd2udqy<T, U>, 

VCVTTPD2UDQY instruction

Instruction	Opcode	CPUID
VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.0F.W1 78 /r	AVX512VL AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttpd2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttpd2uqq<T, U>, 

VCVTTPD2UQQ instruction

Instruction	Opcode	CPUID
VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F.W1 78 /r	AVX512VL AVX512DQ
VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F.W1 78 /r	AVX512VL AVX512DQ
VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}	EVEX.512.66.0F.W1 78 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttph2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttph2dq<T, U>, 

VCVTTPH2DQ instruction

Instruction	Opcode	CPUID
VCVTTPH2DQ xmm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.128.F3.MAP5.W0 5B /r	AVX512VL AVX512-FP16
VCVTTPH2DQ ymm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.256.F3.MAP5.W0 5B /r	AVX512VL AVX512-FP16
VCVTTPH2DQ zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}	EVEX.512.F3.MAP5.W0 5B /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttph2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttph2qq<T, U>, 

VCVTTPH2QQ instruction

Instruction	Opcode	CPUID
VCVTTPH2QQ xmm1 {k1}{z}, xmm2/m32/m16bcst	EVEX.128.66.MAP5.W0 7A /r	AVX512VL AVX512-FP16
VCVTTPH2QQ ymm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.256.66.MAP5.W0 7A /r	AVX512VL AVX512-FP16
VCVTTPH2QQ zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}	EVEX.512.66.MAP5.W0 7A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttph2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttph2udq<T, U>, 

VCVTTPH2UDQ instruction

Instruction	Opcode	CPUID
VCVTTPH2UDQ xmm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.128.MAP5.W0 78 /r	AVX512VL AVX512-FP16
VCVTTPH2UDQ ymm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.256.MAP5.W0 78 /r	AVX512VL AVX512-FP16
VCVTTPH2UDQ zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}	EVEX.512.MAP5.W0 78 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttph2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttph2uqq<T, U>, 

VCVTTPH2UQQ instruction

Instruction	Opcode	CPUID
VCVTTPH2UQQ xmm1 {k1}{z}, xmm2/m32/m16bcst	EVEX.128.66.MAP5.W0 78 /r	AVX512VL AVX512-FP16
VCVTTPH2UQQ ymm1 {k1}{z}, xmm2/m64/m16bcst	EVEX.256.66.MAP5.W0 78 /r	AVX512VL AVX512-FP16
VCVTTPH2UQQ zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}	EVEX.512.66.MAP5.W0 78 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttph2uw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttph2uw<T, U>, 

VCVTTPH2UW instruction

Instruction	Opcode	CPUID
VCVTTPH2UW xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.MAP5.W0 7C /r	AVX512VL AVX512-FP16
VCVTTPH2UW ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.MAP5.W0 7C /r	AVX512VL AVX512-FP16
VCVTTPH2UW zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}	EVEX.512.MAP5.W0 7C /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttph2w<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttph2w<T, U>, 

VCVTTPH2W instruction

Instruction	Opcode	CPUID
VCVTTPH2W xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.66.MAP5.W0 7C /r	AVX512VL AVX512-FP16
VCVTTPH2W ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.66.MAP5.W0 7C /r	AVX512VL AVX512-FP16
VCVTTPH2W zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}	EVEX.512.66.MAP5.W0 7C /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttps2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttps2dq<T, U>, 

VCVTTPS2DQ instruction

Instruction	Opcode	CPUID
VCVTTPS2DQ xmm1, xmm2/m128	VEX.128.F3.0F.WIG 5B /r	AVX
VCVTTPS2DQ ymm1, ymm2/m256	VEX.256.F3.0F.WIG 5B /r	AVX
VCVTTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.F3.0F.W0 5B /r	AVX512VL AVX512F
VCVTTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.F3.0F.W0 5B /r	AVX512VL AVX512F
VCVTTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}	EVEX.512.F3.0F.W0 5B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttps2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttps2qq<T, U>, 

VCVTTPS2QQ instruction

Instruction	Opcode	CPUID
VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst	EVEX.128.66.0F.W0 7A /r	AVX512VL AVX512DQ
VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.256.66.0F.W0 7A /r	AVX512VL AVX512DQ
VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}	EVEX.512.66.0F.W0 7A /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttps2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttps2udq<T, U>, 

VCVTTPS2UDQ instruction

Instruction	Opcode	CPUID
VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.0F.W0 78 /r	AVX512VL AVX512F
VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.0F.W0 78 /r	AVX512VL AVX512F
VCVTTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}	EVEX.512.0F.W0 78 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttps2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttps2uqq<T, U>, 

VCVTTPS2UQQ instruction

Instruction	Opcode	CPUID
VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst	EVEX.128.66.0F.W0 78 /r	AVX512VL AVX512DQ
VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.256.66.0F.W0 78 /r	AVX512VL AVX512DQ
VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}	EVEX.512.66.0F.W0 78 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttsd2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttsd2si<T, U>, 

VCVTTSD2SI instruction

Instruction	Opcode	CPUID
VCVTTSD2SI r32, xmm1/m64	VEX.LIG.F2.0F.W0 2C /r	AVX
VCVTTSD2SI r64, xmm1/m64	VEX.LIG.F2.0F.W1 2C /r	AVX
VCVTTSD2SI r32, xmm1/m64{sae}	EVEX.LIG.F2.0F.W0 2C /r	AVX512F
VCVTTSD2SI r64, xmm1/m64{sae}	EVEX.LIG.F2.0F.W1 2C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttsd2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttsd2usi<T, U>, 

VCVTTSD2USI instruction

Instruction	Opcode	CPUID
VCVTTSD2USI r32, xmm1/m64{sae}	EVEX.LIG.F2.0F.W0 78 /r	AVX512F
VCVTTSD2USI r64, xmm1/m64{sae}	EVEX.LIG.F2.0F.W1 78 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttsh2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttsh2si<T, U>, 

VCVTTSH2SI instruction

Instruction	Opcode	CPUID
VCVTTSH2SI r32, xmm1/m16{sae}	EVEX.LIG.F3.MAP5.W0 2C /r	AVX512-FP16
VCVTTSH2SI r64, xmm1/m16{sae}	EVEX.LIG.F3.MAP5.W1 2C /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttsh2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttsh2usi<T, U>, 

VCVTTSH2USI instruction

Instruction	Opcode	CPUID
VCVTTSH2USI r32, xmm1/m16{sae}	EVEX.LIG.F3.MAP5.W0 78 /r	AVX512-FP16
VCVTTSH2USI r64, xmm1/m16{sae}	EVEX.LIG.F3.MAP5.W1 78 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttss2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttss2si<T, U>, 

VCVTTSS2SI instruction

Instruction	Opcode	CPUID
VCVTTSS2SI r32, xmm1/m32	VEX.LIG.F3.0F.W0 2C /r	AVX
VCVTTSS2SI r64, xmm1/m32	VEX.LIG.F3.0F.W1 2C /r	AVX
VCVTTSS2SI r32, xmm1/m32{sae}	EVEX.LIG.F3.0F.W0 2C /r	AVX512F
VCVTTSS2SI r64, xmm1/m32{sae}	EVEX.LIG.F3.0F.W1 2C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvttss2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvttss2usi<T, U>, 

VCVTTSS2USI instruction

Instruction	Opcode	CPUID
VCVTTSS2USI r32, xmm1/m32{sae}	EVEX.LIG.F3.0F.W0 78 /r	AVX512F
VCVTTSS2USI r64, xmm1/m32{sae}	EVEX.LIG.F3.0F.W1 78 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtudq2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtudq2pd<T, U>, 

VCVTUDQ2PD instruction

Instruction	Opcode	CPUID
VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst	EVEX.128.F3.0F.W0 7A /r	AVX512VL AVX512F
VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.256.F3.0F.W0 7A /r	AVX512VL AVX512F
VCVTUDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{er}	EVEX.512.F3.0F.W0 7A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtudq2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtudq2ph<T, U>, 

VCVTUDQ2PH instruction

Instruction	Opcode	CPUID
VCVTUDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.F2.MAP5.W0 7A /r	AVX512VL AVX512-FP16
VCVTUDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.F2.MAP5.W0 7A /r	AVX512VL AVX512-FP16
VCVTUDQ2PH ymm1 {k1}{z}, zmm2/m512/m32bcst{er}	EVEX.512.F2.MAP5.W0 7A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtudq2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtudq2phx<T, U>, 

VCVTUDQ2PHX instruction

Instruction	Opcode	CPUID
VCVTUDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.F2.MAP5.W0 7A /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtudq2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtudq2phy<T, U>, 

VCVTUDQ2PHY instruction

Instruction	Opcode	CPUID
VCVTUDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.F2.MAP5.W0 7A /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtudq2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtudq2ps<T, U>, 

VCVTUDQ2PS instruction

Instruction	Opcode	CPUID
VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.F2.0F.W0 7A /r	AVX512VL AVX512F
VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.F2.0F.W0 7A /r	AVX512VL AVX512F
VCVTUDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}	EVEX.512.F2.0F.W0 7A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtuqq2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtuqq2pd<T, U>, 

VCVTUQQ2PD instruction

Instruction	Opcode	CPUID
VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.F3.0F.W1 7A /r	AVX512VL AVX512DQ
VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.F3.0F.W1 7A /r	AVX512VL AVX512DQ
VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.F3.0F.W1 7A /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtuqq2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtuqq2ph<T, U>, 

VCVTUQQ2PH instruction

Instruction	Opcode	CPUID
VCVTUQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.F2.MAP5.W1 7A /r	AVX512VL AVX512-FP16
VCVTUQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.F2.MAP5.W1 7A /r	AVX512VL AVX512-FP16
VCVTUQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.F2.MAP5.W1 7A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtuqq2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtuqq2phx<T, U>, 

VCVTUQQ2PHX instruction

Instruction	Opcode	CPUID
VCVTUQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.F2.MAP5.W1 7A /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtuqq2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtuqq2phy<T, U>, 

VCVTUQQ2PHY instruction

Instruction	Opcode	CPUID
VCVTUQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.F2.MAP5.W1 7A /r	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtuqq2phz<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtuqq2phz<T, U>, 

VCVTUQQ2PHZ instruction

Instruction	Opcode	CPUID
VCVTUQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.F2.MAP5.W1 7A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtuqq2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtuqq2ps<T, U>, 

VCVTUQQ2PS instruction

Instruction	Opcode	CPUID
VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.F2.0F.W1 7A /r	AVX512VL AVX512DQ
VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.F2.0F.W1 7A /r	AVX512VL AVX512DQ
VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.F2.0F.W1 7A /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtuqq2psx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtuqq2psx<T, U>, 

VCVTUQQ2PSX instruction

Instruction	Opcode	CPUID
VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.F2.0F.W1 7A /r	AVX512VL AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtuqq2psy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtuqq2psy<T, U>, 

VCVTUQQ2PSY instruction

Instruction	Opcode	CPUID
VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.F2.0F.W1 7A /r	AVX512VL AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtusi2sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtusi2sd<T, U, V>, 

VCVTUSI2SD instruction

Instruction	Opcode	CPUID
VCVTUSI2SD xmm1, xmm2, r/m32{er}	EVEX.LIG.F2.0F.W0 7B /r	AVX512F
VCVTUSI2SD xmm1, xmm2, r/m64{er}	EVEX.LIG.F2.0F.W1 7B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtusi2sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtusi2sh<T, U, V>, 

VCVTUSI2SH instruction

Instruction	Opcode	CPUID
VCVTUSI2SH xmm1, xmm2, r/m32{er}	EVEX.LIG.F3.MAP5.W0 7B /r	AVX512-FP16
VCVTUSI2SH xmm1, xmm2, r/m64{er}	EVEX.LIG.F3.MAP5.W1 7B /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtusi2ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVcvtusi2ss<T, U, V>, 

VCVTUSI2SS instruction

Instruction	Opcode	CPUID
VCVTUSI2SS xmm1, xmm2, r/m32{er}	EVEX.LIG.F3.0F.W0 7B /r	AVX512F
VCVTUSI2SS xmm1, xmm2, r/m64{er}	EVEX.LIG.F3.0F.W1 7B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vcvtuw2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtuw2ph<T, U>, 

VCVTUW2PH instruction

Instruction	Opcode	CPUID
VCVTUW2PH xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.F2.MAP5.W0 7D /r	AVX512VL AVX512-FP16
VCVTUW2PH ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.F2.MAP5.W0 7D /r	AVX512VL AVX512-FP16
VCVTUW2PH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}	EVEX.512.F2.MAP5.W0 7D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vcvtw2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVcvtw2ph<T, U>, 

VCVTW2PH instruction

Instruction	Opcode	CPUID
VCVTW2PH xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.F3.MAP5.W0 7D /r	AVX512VL AVX512-FP16
VCVTW2PH ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.F3.MAP5.W0 7D /r	AVX512VL AVX512-FP16
VCVTW2PH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}	EVEX.512.F3.MAP5.W0 7D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vdbpsadbw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVdbpsadbw<T, U, V, W>, 

VDBPSADBW instruction

Instruction	Opcode	CPUID
VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 42 /r ib	AVX512VL AVX512BW
VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 42 /r ib	AVX512VL AVX512BW
VDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 42 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vdivpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVdivpd<T, U, V>, 

VDIVPD instruction

Instruction	Opcode	CPUID
VDIVPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 5E /r	AVX
VDIVPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 5E /r	AVX
VDIVPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 5E /r	AVX512VL AVX512F
VDIVPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 5E /r	AVX512VL AVX512F
VDIVPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F.W1 5E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vdivph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVdivph<T, U, V>, 

VDIVPH instruction

Instruction	Opcode	CPUID
VDIVPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.MAP5.W0 5E /r	AVX512VL AVX512-FP16
VDIVPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.MAP5.W0 5E /r	AVX512VL AVX512-FP16
VDIVPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.MAP5.W0 5E /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vdivps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVdivps<T, U, V>, 

VDIVPS instruction

Instruction	Opcode	CPUID
VDIVPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 5E /r	AVX
VDIVPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 5E /r	AVX
VDIVPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 5E /r	AVX512VL AVX512F
VDIVPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 5E /r	AVX512VL AVX512F
VDIVPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.0F.W0 5E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vdivsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVdivsd<T, U, V>, 

VDIVSD instruction

Instruction	Opcode	CPUID
VDIVSD xmm1, xmm2, xmm3/m64	VEX.LIG.F2.0F.WIG 5E /r	AVX
VDIVSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.F2.0F.W1 5E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vdivsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVdivsh<T, U, V>, 

VDIVSH instruction

Instruction	Opcode	CPUID
VDIVSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.F3.MAP5.W0 5E /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vdivss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVdivss<T, U, V>, 

VDIVSS instruction

Instruction	Opcode	CPUID
VDIVSS xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 5E /r	AVX
VDIVSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.F3.0F.W0 5E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vdpbf16ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVdpbf16ps<T, U, V>, 

VDPBF16PS instruction

Instruction	Opcode	CPUID
VDPBF16PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.F3.0F38.W0 52 /r	AVX512VL AVX512_BF16
VDPBF16PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.F3.0F38.W0 52 /r	AVX512VL AVX512_BF16
VDPBF16PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.F3.0F38.W0 52 /r	AVX512F AVX512_BF16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vdppd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVdppd<T, U, V, W>, 

VDPPD instruction

Instruction	Opcode	CPUID
VDPPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 41 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vdpps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVdpps<T, U, V, W>, 

VDPPS instruction

Instruction	Opcode	CPUID
VDPPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 40 /r ib	AVX
VDPPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 40 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn verr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVerr<T>, 

VERR instruction

Instruction	Opcode	CPUID
VERR r/m16	o16 0F 00 /4	286+
VERR r32/m16	o32 0F 00 /4	386+
VERR r64/m16	o64 0F 00 /4	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn verw<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVerw<T>, 

VERW instruction

Instruction	Opcode	CPUID
VERW r/m16	o16 0F 00 /5	286+
VERW r32/m16	o32 0F 00 /5	386+
VERW r64/m16	o64 0F 00 /5	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vexp2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVexp2pd<T, U>, 

VEXP2PD instruction

Instruction	Opcode	CPUID
VEXP2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}	EVEX.512.66.0F38.W1 C8 /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vexp2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVexp2ps<T, U>, 

VEXP2PS instruction

Instruction	Opcode	CPUID
VEXP2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}	EVEX.512.66.0F38.W0 C8 /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vexpandpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVexpandpd<T, U>, 

VEXPANDPD instruction

Instruction	Opcode	CPUID
VEXPANDPD xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.W1 88 /r	AVX512VL AVX512F
VEXPANDPD ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.W1 88 /r	AVX512VL AVX512F
VEXPANDPD zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.W1 88 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vexpandps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVexpandps<T, U>, 

VEXPANDPS instruction

Instruction	Opcode	CPUID
VEXPANDPS xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.W0 88 /r	AVX512VL AVX512F
VEXPANDPS ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.W0 88 /r	AVX512VL AVX512F
VEXPANDPS zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.W0 88 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vextractf128<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextractf128<T, U, V>, 

VEXTRACTF128 instruction

Instruction	Opcode	CPUID
VEXTRACTF128 xmm1/m128, ymm2, imm8	VEX.256.66.0F3A.W0 19 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextractf32x4<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextractf32x4<T, U, V>, 

VEXTRACTF32X4 instruction

Instruction	Opcode	CPUID
VEXTRACTF32X4 xmm1/m128 {k1}{z}, ymm2, imm8	EVEX.256.66.0F3A.W0 19 /r ib	AVX512VL AVX512F
VEXTRACTF32X4 xmm1/m128 {k1}{z}, zmm2, imm8	EVEX.512.66.0F3A.W0 19 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextractf32x8<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextractf32x8<T, U, V>, 

VEXTRACTF32X8 instruction

Instruction	Opcode	CPUID
VEXTRACTF32X8 ymm1/m256 {k1}{z}, zmm2, imm8	EVEX.512.66.0F3A.W0 1B /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextractf64x2<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextractf64x2<T, U, V>, 

VEXTRACTF64X2 instruction

Instruction	Opcode	CPUID
VEXTRACTF64X2 xmm1/m128 {k1}{z}, ymm2, imm8	EVEX.256.66.0F3A.W1 19 /r ib	AVX512VL AVX512DQ
VEXTRACTF64X2 xmm1/m128 {k1}{z}, zmm2, imm8	EVEX.512.66.0F3A.W1 19 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextractf64x4<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextractf64x4<T, U, V>, 

VEXTRACTF64X4 instruction

Instruction	Opcode	CPUID
VEXTRACTF64X4 ymm1/m256 {k1}{z}, zmm2, imm8	EVEX.512.66.0F3A.W1 1B /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextracti128<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextracti128<T, U, V>, 

VEXTRACTI128 instruction

Instruction	Opcode	CPUID
VEXTRACTI128 xmm1/m128, ymm2, imm8	VEX.256.66.0F3A.W0 39 /r ib	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextracti32x4<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextracti32x4<T, U, V>, 

VEXTRACTI32X4 instruction

Instruction	Opcode	CPUID
VEXTRACTI32X4 xmm1/m128 {k1}{z}, ymm2, imm8	EVEX.256.66.0F3A.W0 39 /r ib	AVX512VL AVX512F
VEXTRACTI32X4 xmm1/m128 {k1}{z}, zmm2, imm8	EVEX.512.66.0F3A.W0 39 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextracti32x8<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextracti32x8<T, U, V>, 

VEXTRACTI32X8 instruction

Instruction	Opcode	CPUID
VEXTRACTI32X8 ymm1/m256 {k1}{z}, zmm2, imm8	EVEX.512.66.0F3A.W0 3B /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextracti64x2<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextracti64x2<T, U, V>, 

VEXTRACTI64X2 instruction

Instruction	Opcode	CPUID
VEXTRACTI64X2 xmm1/m128 {k1}{z}, ymm2, imm8	EVEX.256.66.0F3A.W1 39 /r ib	AVX512VL AVX512DQ
VEXTRACTI64X2 xmm1/m128 {k1}{z}, zmm2, imm8	EVEX.512.66.0F3A.W1 39 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextracti64x4<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextracti64x4<T, U, V>, 

VEXTRACTI64X4 instruction

Instruction	Opcode	CPUID
VEXTRACTI64X4 ymm1/m256 {k1}{z}, zmm2, imm8	EVEX.512.66.0F3A.W1 3B /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vextractps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVextractps<T, U, V>, 

VEXTRACTPS instruction

Instruction	Opcode	CPUID
VEXTRACTPS r/m32, xmm1, imm8	VEX.128.66.0F3A.W0 17 /r ib	AVX
VEXTRACTPS r64/m32, xmm1, imm8	VEX.128.66.0F3A.W1 17 /r ib	AVX
VEXTRACTPS r/m32, xmm1, imm8	EVEX.128.66.0F3A.W0 17 /r ib	AVX512F
VEXTRACTPS r64/m32, xmm1, imm8	EVEX.128.66.0F3A.W1 17 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfcmaddcph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfcmaddcph<T, U, V>, 

VFCMADDCPH instruction

Instruction	Opcode	CPUID
VFCMADDCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.F2.MAP6.W0 56 /r	AVX512VL AVX512-FP16
VFCMADDCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.F2.MAP6.W0 56 /r	AVX512VL AVX512-FP16
VFCMADDCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.F2.MAP6.W0 56 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfcmaddcsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfcmaddcsh<T, U, V>, 

VFCMADDCSH instruction

Instruction	Opcode	CPUID
VFCMADDCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.F2.MAP6.W0 57 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfcmulcph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfcmulcph<T, U, V>, 

VFCMULCPH instruction

Instruction	Opcode	CPUID
VFCMULCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.F2.MAP6.W0 D6 /r	AVX512VL AVX512-FP16
VFCMULCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.F2.MAP6.W0 D6 /r	AVX512VL AVX512-FP16
VFCMULCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.F2.MAP6.W0 D6 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfcmulcsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfcmulcsh<T, U, V>, 

VFCMULCSH instruction

Instruction	Opcode	CPUID
VFCMULCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.F2.MAP6.W0 D7 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfixupimmpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfixupimmpd<T, U, V, W>, 

VFIXUPIMMPD instruction

Instruction	Opcode	CPUID
VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 54 /r ib	AVX512VL AVX512F
VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 54 /r ib	AVX512VL AVX512F
VFIXUPIMMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F3A.W1 54 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfixupimmps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfixupimmps<T, U, V, W>, 

VFIXUPIMMPS instruction

Instruction	Opcode	CPUID
VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 54 /r ib	AVX512VL AVX512F
VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 54 /r ib	AVX512VL AVX512F
VFIXUPIMMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.66.0F3A.W0 54 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfixupimmsd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfixupimmsd<T, U, V, W>, 

VFIXUPIMMSD instruction

Instruction	Opcode	CPUID
VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.66.0F3A.W1 55 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfixupimmss<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfixupimmss<T, U, V, W>, 

VFIXUPIMMSS instruction

Instruction	Opcode	CPUID
VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.66.0F3A.W0 55 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmadd132pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd132pd<T, U, V>, 

VFMADD132PD instruction

Instruction	Opcode	CPUID
VFMADD132PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 98 /r	FMA
VFMADD132PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 98 /r	FMA
VFMADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 98 /r	AVX512VL AVX512F
VFMADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 98 /r	AVX512VL AVX512F
VFMADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 98 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd132ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd132ph<T, U, V>, 

VFMADD132PH instruction

Instruction	Opcode	CPUID
VFMADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 98 /r	AVX512VL AVX512-FP16
VFMADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 98 /r	AVX512VL AVX512-FP16
VFMADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 98 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd132ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd132ps<T, U, V>, 

VFMADD132PS instruction

Instruction	Opcode	CPUID
VFMADD132PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 98 /r	FMA
VFMADD132PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 98 /r	FMA
VFMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 98 /r	AVX512VL AVX512F
VFMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 98 /r	AVX512VL AVX512F
VFMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 98 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd132sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd132sd<T, U, V>, 

VFMADD132SD instruction

Instruction	Opcode	CPUID
VFMADD132SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 99 /r	FMA
VFMADD132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 99 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd132sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd132sh<T, U, V>, 

VFMADD132SH instruction

Instruction	Opcode	CPUID
VFMADD132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 99 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd132ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd132ss<T, U, V>, 

VFMADD132SS instruction

Instruction	Opcode	CPUID
VFMADD132SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 99 /r	FMA
VFMADD132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 99 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd213pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd213pd<T, U, V>, 

VFMADD213PD instruction

Instruction	Opcode	CPUID
VFMADD213PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 A8 /r	FMA
VFMADD213PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 A8 /r	FMA
VFMADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 A8 /r	AVX512VL AVX512F
VFMADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 A8 /r	AVX512VL AVX512F
VFMADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 A8 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd213ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd213ph<T, U, V>, 

VFMADD213PH instruction

Instruction	Opcode	CPUID
VFMADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 A8 /r	AVX512VL AVX512-FP16
VFMADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 A8 /r	AVX512VL AVX512-FP16
VFMADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 A8 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd213ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd213ps<T, U, V>, 

VFMADD213PS instruction

Instruction	Opcode	CPUID
VFMADD213PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 A8 /r	FMA
VFMADD213PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 A8 /r	FMA
VFMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 A8 /r	AVX512VL AVX512F
VFMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 A8 /r	AVX512VL AVX512F
VFMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 A8 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd213sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd213sd<T, U, V>, 

VFMADD213SD instruction

Instruction	Opcode	CPUID
VFMADD213SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 A9 /r	FMA
VFMADD213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 A9 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd213sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd213sh<T, U, V>, 

VFMADD213SH instruction

Instruction	Opcode	CPUID
VFMADD213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 A9 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd213ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd213ss<T, U, V>, 

VFMADD213SS instruction

Instruction	Opcode	CPUID
VFMADD213SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 A9 /r	FMA
VFMADD213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 A9 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd231pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd231pd<T, U, V>, 

VFMADD231PD instruction

Instruction	Opcode	CPUID
VFMADD231PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 B8 /r	FMA
VFMADD231PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 B8 /r	FMA
VFMADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 B8 /r	AVX512VL AVX512F
VFMADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 B8 /r	AVX512VL AVX512F
VFMADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 B8 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd231ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd231ph<T, U, V>, 

VFMADD231PH instruction

Instruction	Opcode	CPUID
VFMADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 B8 /r	AVX512VL AVX512-FP16
VFMADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 B8 /r	AVX512VL AVX512-FP16
VFMADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 B8 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd231ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd231ps<T, U, V>, 

VFMADD231PS instruction

Instruction	Opcode	CPUID
VFMADD231PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 B8 /r	FMA
VFMADD231PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 B8 /r	FMA
VFMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 B8 /r	AVX512VL AVX512F
VFMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 B8 /r	AVX512VL AVX512F
VFMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 B8 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd231sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd231sd<T, U, V>, 

VFMADD231SD instruction

Instruction	Opcode	CPUID
VFMADD231SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 B9 /r	FMA
VFMADD231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 B9 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd231sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd231sh<T, U, V>, 

VFMADD231SH instruction

Instruction	Opcode	CPUID
VFMADD231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 B9 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmadd231ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmadd231ss<T, U, V>, 

VFMADD231SS instruction

Instruction	Opcode	CPUID
VFMADD231SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 B9 /r	FMA
VFMADD231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 B9 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddcph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddcph<T, U, V>, 

VFMADDCPH instruction

Instruction	Opcode	CPUID
VFMADDCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.F3.MAP6.W0 56 /r	AVX512VL AVX512-FP16
VFMADDCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.F3.MAP6.W0 56 /r	AVX512VL AVX512-FP16
VFMADDCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.F3.MAP6.W0 56 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddcsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddcsh<T, U, V>, 

VFMADDCSH instruction

Instruction	Opcode	CPUID
VFMADDCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.F3.MAP6.W0 57 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddpd<T, U, V, W>, 

VFMADDPD instruction

Instruction	Opcode	CPUID
VFMADDPD xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 69 /r /is4	FMA4
VFMADDPD ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 69 /r /is4	FMA4
VFMADDPD xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 69 /r /is4	FMA4
VFMADDPD ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 69 /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmaddps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddps<T, U, V, W>, 

VFMADDPS instruction

Instruction	Opcode	CPUID
VFMADDPS xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 68 /r /is4	FMA4
VFMADDPS ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 68 /r /is4	FMA4
VFMADDPS xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 68 /r /is4	FMA4
VFMADDPS ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 68 /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmaddsd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsd<T, U, V, W>, 

VFMADDSD instruction

Instruction	Opcode	CPUID
VFMADDSD xmm1, xmm2, xmm3/m64, xmm4	VEX.LIG.66.0F3A.W0 6B /r /is4	FMA4
VFMADDSD xmm1, xmm2, xmm3, xmm4/m64	VEX.LIG.66.0F3A.W1 6B /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmaddss<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddss<T, U, V, W>, 

VFMADDSS instruction

Instruction	Opcode	CPUID
VFMADDSS xmm1, xmm2, xmm3/m32, xmm4	VEX.LIG.66.0F3A.W0 6A /r /is4	FMA4
VFMADDSS xmm1, xmm2, xmm3, xmm4/m32	VEX.LIG.66.0F3A.W1 6A /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmaddsub132pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsub132pd<T, U, V>, 

VFMADDSUB132PD instruction

Instruction	Opcode	CPUID
VFMADDSUB132PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 96 /r	FMA
VFMADDSUB132PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 96 /r	FMA
VFMADDSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 96 /r	AVX512VL AVX512F
VFMADDSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 96 /r	AVX512VL AVX512F
VFMADDSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 96 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddsub132ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsub132ph<T, U, V>, 

VFMADDSUB132PH instruction

Instruction	Opcode	CPUID
VFMADDSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 96 /r	AVX512VL AVX512-FP16
VFMADDSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 96 /r	AVX512VL AVX512-FP16
VFMADDSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 96 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddsub132ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsub132ps<T, U, V>, 

VFMADDSUB132PS instruction

Instruction	Opcode	CPUID
VFMADDSUB132PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 96 /r	FMA
VFMADDSUB132PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 96 /r	FMA
VFMADDSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 96 /r	AVX512VL AVX512F
VFMADDSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 96 /r	AVX512VL AVX512F
VFMADDSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 96 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddsub213pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsub213pd<T, U, V>, 

VFMADDSUB213PD instruction

Instruction	Opcode	CPUID
VFMADDSUB213PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 A6 /r	FMA
VFMADDSUB213PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 A6 /r	FMA
VFMADDSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 A6 /r	AVX512VL AVX512F
VFMADDSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 A6 /r	AVX512VL AVX512F
VFMADDSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 A6 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddsub213ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsub213ph<T, U, V>, 

VFMADDSUB213PH instruction

Instruction	Opcode	CPUID
VFMADDSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 A6 /r	AVX512VL AVX512-FP16
VFMADDSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 A6 /r	AVX512VL AVX512-FP16
VFMADDSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 A6 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddsub213ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsub213ps<T, U, V>, 

VFMADDSUB213PS instruction

Instruction	Opcode	CPUID
VFMADDSUB213PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 A6 /r	FMA
VFMADDSUB213PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 A6 /r	FMA
VFMADDSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 A6 /r	AVX512VL AVX512F
VFMADDSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 A6 /r	AVX512VL AVX512F
VFMADDSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 A6 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddsub231pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsub231pd<T, U, V>, 

VFMADDSUB231PD instruction

Instruction	Opcode	CPUID
VFMADDSUB231PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 B6 /r	FMA
VFMADDSUB231PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 B6 /r	FMA
VFMADDSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 B6 /r	AVX512VL AVX512F
VFMADDSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 B6 /r	AVX512VL AVX512F
VFMADDSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 B6 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddsub231ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsub231ph<T, U, V>, 

VFMADDSUB231PH instruction

Instruction	Opcode	CPUID
VFMADDSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 B6 /r	AVX512VL AVX512-FP16
VFMADDSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 B6 /r	AVX512VL AVX512-FP16
VFMADDSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 B6 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddsub231ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsub231ps<T, U, V>, 

VFMADDSUB231PS instruction

Instruction	Opcode	CPUID
VFMADDSUB231PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 B6 /r	FMA
VFMADDSUB231PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 B6 /r	FMA
VFMADDSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 B6 /r	AVX512VL AVX512F
VFMADDSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 B6 /r	AVX512VL AVX512F
VFMADDSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 B6 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmaddsubpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsubpd<T, U, V, W>, 

VFMADDSUBPD instruction

Instruction	Opcode	CPUID
VFMADDSUBPD xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 5D /r /is4	FMA4
VFMADDSUBPD ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 5D /r /is4	FMA4
VFMADDSUBPD xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 5D /r /is4	FMA4
VFMADDSUBPD ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 5D /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmaddsubps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmaddsubps<T, U, V, W>, 

VFMADDSUBPS instruction

Instruction	Opcode	CPUID
VFMADDSUBPS xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 5C /r /is4	FMA4
VFMADDSUBPS ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 5C /r /is4	FMA4
VFMADDSUBPS xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 5C /r /is4	FMA4
VFMADDSUBPS ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 5C /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmsub132pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub132pd<T, U, V>, 

VFMSUB132PD instruction

Instruction	Opcode	CPUID
VFMSUB132PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 9A /r	FMA
VFMSUB132PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 9A /r	FMA
VFMSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 9A /r	AVX512VL AVX512F
VFMSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 9A /r	AVX512VL AVX512F
VFMSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 9A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub132ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub132ph<T, U, V>, 

VFMSUB132PH instruction

Instruction	Opcode	CPUID
VFMSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 9A /r	AVX512VL AVX512-FP16
VFMSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 9A /r	AVX512VL AVX512-FP16
VFMSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 9A /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub132ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub132ps<T, U, V>, 

VFMSUB132PS instruction

Instruction	Opcode	CPUID
VFMSUB132PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 9A /r	FMA
VFMSUB132PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 9A /r	FMA
VFMSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 9A /r	AVX512VL AVX512F
VFMSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 9A /r	AVX512VL AVX512F
VFMSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 9A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub132sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub132sd<T, U, V>, 

VFMSUB132SD instruction

Instruction	Opcode	CPUID
VFMSUB132SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 9B /r	FMA
VFMSUB132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 9B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub132sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub132sh<T, U, V>, 

VFMSUB132SH instruction

Instruction	Opcode	CPUID
VFMSUB132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 9B /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub132ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub132ss<T, U, V>, 

VFMSUB132SS instruction

Instruction	Opcode	CPUID
VFMSUB132SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 9B /r	FMA
VFMSUB132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 9B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub213pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub213pd<T, U, V>, 

VFMSUB213PD instruction

Instruction	Opcode	CPUID
VFMSUB213PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 AA /r	FMA
VFMSUB213PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 AA /r	FMA
VFMSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 AA /r	AVX512VL AVX512F
VFMSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 AA /r	AVX512VL AVX512F
VFMSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 AA /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub213ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub213ph<T, U, V>, 

VFMSUB213PH instruction

Instruction	Opcode	CPUID
VFMSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 AA /r	AVX512VL AVX512-FP16
VFMSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 AA /r	AVX512VL AVX512-FP16
VFMSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 AA /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub213ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub213ps<T, U, V>, 

VFMSUB213PS instruction

Instruction	Opcode	CPUID
VFMSUB213PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 AA /r	FMA
VFMSUB213PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 AA /r	FMA
VFMSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 AA /r	AVX512VL AVX512F
VFMSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 AA /r	AVX512VL AVX512F
VFMSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 AA /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub213sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub213sd<T, U, V>, 

VFMSUB213SD instruction

Instruction	Opcode	CPUID
VFMSUB213SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 AB /r	FMA
VFMSUB213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 AB /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub213sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub213sh<T, U, V>, 

VFMSUB213SH instruction

Instruction	Opcode	CPUID
VFMSUB213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 AB /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub213ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub213ss<T, U, V>, 

VFMSUB213SS instruction

Instruction	Opcode	CPUID
VFMSUB213SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 AB /r	FMA
VFMSUB213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 AB /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub231pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub231pd<T, U, V>, 

VFMSUB231PD instruction

Instruction	Opcode	CPUID
VFMSUB231PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 BA /r	FMA
VFMSUB231PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 BA /r	FMA
VFMSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 BA /r	AVX512VL AVX512F
VFMSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 BA /r	AVX512VL AVX512F
VFMSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 BA /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub231ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub231ph<T, U, V>, 

VFMSUB231PH instruction

Instruction	Opcode	CPUID
VFMSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 BA /r	AVX512VL AVX512-FP16
VFMSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 BA /r	AVX512VL AVX512-FP16
VFMSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 BA /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub231ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub231ps<T, U, V>, 

VFMSUB231PS instruction

Instruction	Opcode	CPUID
VFMSUB231PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 BA /r	FMA
VFMSUB231PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 BA /r	FMA
VFMSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 BA /r	AVX512VL AVX512F
VFMSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 BA /r	AVX512VL AVX512F
VFMSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 BA /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub231sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub231sd<T, U, V>, 

VFMSUB231SD instruction

Instruction	Opcode	CPUID
VFMSUB231SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 BB /r	FMA
VFMSUB231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 BB /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub231sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub231sh<T, U, V>, 

VFMSUB231SH instruction

Instruction	Opcode	CPUID
VFMSUB231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 BB /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsub231ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsub231ss<T, U, V>, 

VFMSUB231SS instruction

Instruction	Opcode	CPUID
VFMSUB231SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 BB /r	FMA
VFMSUB231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 BB /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubadd132pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubadd132pd<T, U, V>, 

VFMSUBADD132PD instruction

Instruction	Opcode	CPUID
VFMSUBADD132PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 97 /r	FMA
VFMSUBADD132PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 97 /r	FMA
VFMSUBADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 97 /r	AVX512VL AVX512F
VFMSUBADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 97 /r	AVX512VL AVX512F
VFMSUBADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 97 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubadd132ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubadd132ph<T, U, V>, 

VFMSUBADD132PH instruction

Instruction	Opcode	CPUID
VFMSUBADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 97 /r	AVX512VL AVX512-FP16
VFMSUBADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 97 /r	AVX512VL AVX512-FP16
VFMSUBADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 97 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubadd132ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubadd132ps<T, U, V>, 

VFMSUBADD132PS instruction

Instruction	Opcode	CPUID
VFMSUBADD132PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 97 /r	FMA
VFMSUBADD132PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 97 /r	FMA
VFMSUBADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 97 /r	AVX512VL AVX512F
VFMSUBADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 97 /r	AVX512VL AVX512F
VFMSUBADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 97 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubadd213pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubadd213pd<T, U, V>, 

VFMSUBADD213PD instruction

Instruction	Opcode	CPUID
VFMSUBADD213PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 A7 /r	FMA
VFMSUBADD213PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 A7 /r	FMA
VFMSUBADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 A7 /r	AVX512VL AVX512F
VFMSUBADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 A7 /r	AVX512VL AVX512F
VFMSUBADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 A7 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubadd213ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubadd213ph<T, U, V>, 

VFMSUBADD213PH instruction

Instruction	Opcode	CPUID
VFMSUBADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 A7 /r	AVX512VL AVX512-FP16
VFMSUBADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 A7 /r	AVX512VL AVX512-FP16
VFMSUBADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 A7 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubadd213ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubadd213ps<T, U, V>, 

VFMSUBADD213PS instruction

Instruction	Opcode	CPUID
VFMSUBADD213PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 A7 /r	FMA
VFMSUBADD213PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 A7 /r	FMA
VFMSUBADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 A7 /r	AVX512VL AVX512F
VFMSUBADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 A7 /r	AVX512VL AVX512F
VFMSUBADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 A7 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubadd231pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubadd231pd<T, U, V>, 

VFMSUBADD231PD instruction

Instruction	Opcode	CPUID
VFMSUBADD231PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 B7 /r	FMA
VFMSUBADD231PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 B7 /r	FMA
VFMSUBADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 B7 /r	AVX512VL AVX512F
VFMSUBADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 B7 /r	AVX512VL AVX512F
VFMSUBADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 B7 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubadd231ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubadd231ph<T, U, V>, 

VFMSUBADD231PH instruction

Instruction	Opcode	CPUID
VFMSUBADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 B7 /r	AVX512VL AVX512-FP16
VFMSUBADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 B7 /r	AVX512VL AVX512-FP16
VFMSUBADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 B7 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubadd231ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubadd231ps<T, U, V>, 

VFMSUBADD231PS instruction

Instruction	Opcode	CPUID
VFMSUBADD231PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 B7 /r	FMA
VFMSUBADD231PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 B7 /r	FMA
VFMSUBADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 B7 /r	AVX512VL AVX512F
VFMSUBADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 B7 /r	AVX512VL AVX512F
VFMSUBADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 B7 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmsubaddpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubaddpd<T, U, V, W>, 

VFMSUBADDPD instruction

Instruction	Opcode	CPUID
VFMSUBADDPD xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 5F /r /is4	FMA4
VFMSUBADDPD ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 5F /r /is4	FMA4
VFMSUBADDPD xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 5F /r /is4	FMA4
VFMSUBADDPD ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 5F /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmsubaddps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubaddps<T, U, V, W>, 

VFMSUBADDPS instruction

Instruction	Opcode	CPUID
VFMSUBADDPS xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 5E /r /is4	FMA4
VFMSUBADDPS ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 5E /r /is4	FMA4
VFMSUBADDPS xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 5E /r /is4	FMA4
VFMSUBADDPS ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 5E /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmsubpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubpd<T, U, V, W>, 

VFMSUBPD instruction

Instruction	Opcode	CPUID
VFMSUBPD xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 6D /r /is4	FMA4
VFMSUBPD ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 6D /r /is4	FMA4
VFMSUBPD xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 6D /r /is4	FMA4
VFMSUBPD ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 6D /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmsubps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubps<T, U, V, W>, 

VFMSUBPS instruction

Instruction	Opcode	CPUID
VFMSUBPS xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 6C /r /is4	FMA4
VFMSUBPS ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 6C /r /is4	FMA4
VFMSUBPS xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 6C /r /is4	FMA4
VFMSUBPS ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 6C /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmsubsd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubsd<T, U, V, W>, 

VFMSUBSD instruction

Instruction	Opcode	CPUID
VFMSUBSD xmm1, xmm2, xmm3/m64, xmm4	VEX.LIG.66.0F3A.W0 6F /r /is4	FMA4
VFMSUBSD xmm1, xmm2, xmm3, xmm4/m64	VEX.LIG.66.0F3A.W1 6F /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmsubss<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfmsubss<T, U, V, W>, 

VFMSUBSS instruction

Instruction	Opcode	CPUID
VFMSUBSS xmm1, xmm2, xmm3/m32, xmm4	VEX.LIG.66.0F3A.W0 6E /r /is4	FMA4
VFMSUBSS xmm1, xmm2, xmm3, xmm4/m32	VEX.LIG.66.0F3A.W1 6E /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfmulcph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmulcph<T, U, V>, 

VFMULCPH instruction

Instruction	Opcode	CPUID
VFMULCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.F3.MAP6.W0 D6 /r	AVX512VL AVX512-FP16
VFMULCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.F3.MAP6.W0 D6 /r	AVX512VL AVX512-FP16
VFMULCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.F3.MAP6.W0 D6 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfmulcsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfmulcsh<T, U, V>, 

VFMULCSH instruction

Instruction	Opcode	CPUID
VFMULCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.F3.MAP6.W0 D7 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd132pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd132pd<T, U, V>, 

VFNMADD132PD instruction

Instruction	Opcode	CPUID
VFNMADD132PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 9C /r	FMA
VFNMADD132PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 9C /r	FMA
VFNMADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 9C /r	AVX512VL AVX512F
VFNMADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 9C /r	AVX512VL AVX512F
VFNMADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 9C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd132ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd132ph<T, U, V>, 

VFNMADD132PH instruction

Instruction	Opcode	CPUID
VFNMADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 9C /r	AVX512VL AVX512-FP16
VFNMADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 9C /r	AVX512VL AVX512-FP16
VFNMADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 9C /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd132ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd132ps<T, U, V>, 

VFNMADD132PS instruction

Instruction	Opcode	CPUID
VFNMADD132PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 9C /r	FMA
VFNMADD132PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 9C /r	FMA
VFNMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 9C /r	AVX512VL AVX512F
VFNMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 9C /r	AVX512VL AVX512F
VFNMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 9C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd132sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd132sd<T, U, V>, 

VFNMADD132SD instruction

Instruction	Opcode	CPUID
VFNMADD132SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 9D /r	FMA
VFNMADD132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 9D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd132sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd132sh<T, U, V>, 

VFNMADD132SH instruction

Instruction	Opcode	CPUID
VFNMADD132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 9D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd132ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd132ss<T, U, V>, 

VFNMADD132SS instruction

Instruction	Opcode	CPUID
VFNMADD132SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 9D /r	FMA
VFNMADD132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 9D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd213pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd213pd<T, U, V>, 

VFNMADD213PD instruction

Instruction	Opcode	CPUID
VFNMADD213PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 AC /r	FMA
VFNMADD213PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 AC /r	FMA
VFNMADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 AC /r	AVX512VL AVX512F
VFNMADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 AC /r	AVX512VL AVX512F
VFNMADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 AC /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd213ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd213ph<T, U, V>, 

VFNMADD213PH instruction

Instruction	Opcode	CPUID
VFNMADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 AC /r	AVX512VL AVX512-FP16
VFNMADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 AC /r	AVX512VL AVX512-FP16
VFNMADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 AC /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd213ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd213ps<T, U, V>, 

VFNMADD213PS instruction

Instruction	Opcode	CPUID
VFNMADD213PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 AC /r	FMA
VFNMADD213PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 AC /r	FMA
VFNMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 AC /r	AVX512VL AVX512F
VFNMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 AC /r	AVX512VL AVX512F
VFNMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 AC /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd213sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd213sd<T, U, V>, 

VFNMADD213SD instruction

Instruction	Opcode	CPUID
VFNMADD213SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 AD /r	FMA
VFNMADD213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 AD /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd213sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd213sh<T, U, V>, 

VFNMADD213SH instruction

Instruction	Opcode	CPUID
VFNMADD213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 AD /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd213ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd213ss<T, U, V>, 

VFNMADD213SS instruction

Instruction	Opcode	CPUID
VFNMADD213SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 AD /r	FMA
VFNMADD213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 AD /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd231pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd231pd<T, U, V>, 

VFNMADD231PD instruction

Instruction	Opcode	CPUID
VFNMADD231PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 BC /r	FMA
VFNMADD231PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 BC /r	FMA
VFNMADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 BC /r	AVX512VL AVX512F
VFNMADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 BC /r	AVX512VL AVX512F
VFNMADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 BC /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd231ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd231ph<T, U, V>, 

VFNMADD231PH instruction

Instruction	Opcode	CPUID
VFNMADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 BC /r	AVX512VL AVX512-FP16
VFNMADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 BC /r	AVX512VL AVX512-FP16
VFNMADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 BC /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd231ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd231ps<T, U, V>, 

VFNMADD231PS instruction

Instruction	Opcode	CPUID
VFNMADD231PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 BC /r	FMA
VFNMADD231PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 BC /r	FMA
VFNMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 BC /r	AVX512VL AVX512F
VFNMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 BC /r	AVX512VL AVX512F
VFNMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 BC /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd231sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd231sd<T, U, V>, 

VFNMADD231SD instruction

Instruction	Opcode	CPUID
VFNMADD231SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 BD /r	FMA
VFNMADD231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 BD /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd231sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd231sh<T, U, V>, 

VFNMADD231SH instruction

Instruction	Opcode	CPUID
VFNMADD231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 BD /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmadd231ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmadd231ss<T, U, V>, 

VFNMADD231SS instruction

Instruction	Opcode	CPUID
VFNMADD231SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 BD /r	FMA
VFNMADD231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 BD /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmaddpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmaddpd<T, U, V, W>, 

VFNMADDPD instruction

Instruction	Opcode	CPUID
VFNMADDPD xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 79 /r /is4	FMA4
VFNMADDPD ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 79 /r /is4	FMA4
VFNMADDPD xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 79 /r /is4	FMA4
VFNMADDPD ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 79 /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfnmaddps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmaddps<T, U, V, W>, 

VFNMADDPS instruction

Instruction	Opcode	CPUID
VFNMADDPS xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 78 /r /is4	FMA4
VFNMADDPS ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 78 /r /is4	FMA4
VFNMADDPS xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 78 /r /is4	FMA4
VFNMADDPS ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 78 /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfnmaddsd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmaddsd<T, U, V, W>, 

VFNMADDSD instruction

Instruction	Opcode	CPUID
VFNMADDSD xmm1, xmm2, xmm3/m64, xmm4	VEX.LIG.66.0F3A.W0 7B /r /is4	FMA4
VFNMADDSD xmm1, xmm2, xmm3, xmm4/m64	VEX.LIG.66.0F3A.W1 7B /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfnmaddss<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmaddss<T, U, V, W>, 

VFNMADDSS instruction

Instruction	Opcode	CPUID
VFNMADDSS xmm1, xmm2, xmm3/m32, xmm4	VEX.LIG.66.0F3A.W0 7A /r /is4	FMA4
VFNMADDSS xmm1, xmm2, xmm3, xmm4/m32	VEX.LIG.66.0F3A.W1 7A /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfnmsub132pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub132pd<T, U, V>, 

VFNMSUB132PD instruction

Instruction	Opcode	CPUID
VFNMSUB132PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 9E /r	FMA
VFNMSUB132PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 9E /r	FMA
VFNMSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 9E /r	AVX512VL AVX512F
VFNMSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 9E /r	AVX512VL AVX512F
VFNMSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 9E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub132ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub132ph<T, U, V>, 

VFNMSUB132PH instruction

Instruction	Opcode	CPUID
VFNMSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 9E /r	AVX512VL AVX512-FP16
VFNMSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 9E /r	AVX512VL AVX512-FP16
VFNMSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 9E /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub132ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub132ps<T, U, V>, 

VFNMSUB132PS instruction

Instruction	Opcode	CPUID
VFNMSUB132PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 9E /r	FMA
VFNMSUB132PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 9E /r	FMA
VFNMSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 9E /r	AVX512VL AVX512F
VFNMSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 9E /r	AVX512VL AVX512F
VFNMSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 9E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub132sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub132sd<T, U, V>, 

VFNMSUB132SD instruction

Instruction	Opcode	CPUID
VFNMSUB132SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 9F /r	FMA
VFNMSUB132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 9F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub132sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub132sh<T, U, V>, 

VFNMSUB132SH instruction

Instruction	Opcode	CPUID
VFNMSUB132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 9F /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub132ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub132ss<T, U, V>, 

VFNMSUB132SS instruction

Instruction	Opcode	CPUID
VFNMSUB132SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 9F /r	FMA
VFNMSUB132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 9F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub213pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub213pd<T, U, V>, 

VFNMSUB213PD instruction

Instruction	Opcode	CPUID
VFNMSUB213PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 AE /r	FMA
VFNMSUB213PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 AE /r	FMA
VFNMSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 AE /r	AVX512VL AVX512F
VFNMSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 AE /r	AVX512VL AVX512F
VFNMSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 AE /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub213ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub213ph<T, U, V>, 

VFNMSUB213PH instruction

Instruction	Opcode	CPUID
VFNMSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 AE /r	AVX512VL AVX512-FP16
VFNMSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 AE /r	AVX512VL AVX512-FP16
VFNMSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 AE /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub213ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub213ps<T, U, V>, 

VFNMSUB213PS instruction

Instruction	Opcode	CPUID
VFNMSUB213PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 AE /r	FMA
VFNMSUB213PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 AE /r	FMA
VFNMSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 AE /r	AVX512VL AVX512F
VFNMSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 AE /r	AVX512VL AVX512F
VFNMSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 AE /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub213sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub213sd<T, U, V>, 

VFNMSUB213SD instruction

Instruction	Opcode	CPUID
VFNMSUB213SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 AF /r	FMA
VFNMSUB213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 AF /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub213sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub213sh<T, U, V>, 

VFNMSUB213SH instruction

Instruction	Opcode	CPUID
VFNMSUB213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 AF /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub213ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub213ss<T, U, V>, 

VFNMSUB213SS instruction

Instruction	Opcode	CPUID
VFNMSUB213SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 AF /r	FMA
VFNMSUB213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 AF /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub231pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub231pd<T, U, V>, 

VFNMSUB231PD instruction

Instruction	Opcode	CPUID
VFNMSUB231PD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 BE /r	FMA
VFNMSUB231PD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 BE /r	FMA
VFNMSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 BE /r	AVX512VL AVX512F
VFNMSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 BE /r	AVX512VL AVX512F
VFNMSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 BE /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub231ph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub231ph<T, U, V>, 

VFNMSUB231PH instruction

Instruction	Opcode	CPUID
VFNMSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 BE /r	AVX512VL AVX512-FP16
VFNMSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 BE /r	AVX512VL AVX512-FP16
VFNMSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 BE /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub231ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub231ps<T, U, V>, 

VFNMSUB231PS instruction

Instruction	Opcode	CPUID
VFNMSUB231PS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 BE /r	FMA
VFNMSUB231PS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 BE /r	FMA
VFNMSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 BE /r	AVX512VL AVX512F
VFNMSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 BE /r	AVX512VL AVX512F
VFNMSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 BE /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub231sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub231sd<T, U, V>, 

VFNMSUB231SD instruction

Instruction	Opcode	CPUID
VFNMSUB231SD xmm1, xmm2, xmm3/m64	VEX.LIG.66.0F38.W1 BF /r	FMA
VFNMSUB231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 BF /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub231sh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub231sh<T, U, V>, 

VFNMSUB231SH instruction

Instruction	Opcode	CPUID
VFNMSUB231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 BF /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsub231ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsub231ss<T, U, V>, 

VFNMSUB231SS instruction

Instruction	Opcode	CPUID
VFNMSUB231SS xmm1, xmm2, xmm3/m32	VEX.LIG.66.0F38.W0 BF /r	FMA
VFNMSUB231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 BF /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfnmsubpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsubpd<T, U, V, W>, 

VFNMSUBPD instruction

Instruction	Opcode	CPUID
VFNMSUBPD xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 7D /r /is4	FMA4
VFNMSUBPD ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 7D /r /is4	FMA4
VFNMSUBPD xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 7D /r /is4	FMA4
VFNMSUBPD ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 7D /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfnmsubps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsubps<T, U, V, W>, 

VFNMSUBPS instruction

Instruction	Opcode	CPUID
VFNMSUBPS xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 7C /r /is4	FMA4
VFNMSUBPS ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 7C /r /is4	FMA4
VFNMSUBPS xmm1, xmm2, xmm3, xmm4/m128	VEX.128.66.0F3A.W1 7C /r /is4	FMA4
VFNMSUBPS ymm1, ymm2, ymm3, ymm4/m256	VEX.256.66.0F3A.W1 7C /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfnmsubsd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsubsd<T, U, V, W>, 

VFNMSUBSD instruction

Instruction	Opcode	CPUID
VFNMSUBSD xmm1, xmm2, xmm3/m64, xmm4	VEX.LIG.66.0F3A.W0 7F /r /is4	FMA4
VFNMSUBSD xmm1, xmm2, xmm3, xmm4/m64	VEX.LIG.66.0F3A.W1 7F /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfnmsubss<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVfnmsubss<T, U, V, W>, 

VFNMSUBSS instruction

Instruction	Opcode	CPUID
VFNMSUBSS xmm1, xmm2, xmm3/m32, xmm4	VEX.LIG.66.0F3A.W0 7E /r /is4	FMA4
VFNMSUBSS xmm1, xmm2, xmm3, xmm4/m32	VEX.LIG.66.0F3A.W1 7E /r /is4	FMA4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vfpclasspd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclasspd<T, U, V>, 

VFPCLASSPD instruction

Instruction	Opcode	CPUID
VFPCLASSPD k2 {k1}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 66 /r ib	AVX512VL AVX512DQ
VFPCLASSPD k2 {k1}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 66 /r ib	AVX512VL AVX512DQ
VFPCLASSPD k2 {k1}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 66 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclasspdx<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclasspdx<T, U, V>, 

VFPCLASSPDX instruction

Instruction	Opcode	CPUID
VFPCLASSPD k2 {k1}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 66 /r ib	AVX512VL AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclasspdy<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclasspdy<T, U, V>, 

VFPCLASSPDY instruction

Instruction	Opcode	CPUID
VFPCLASSPD k2 {k1}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 66 /r ib	AVX512VL AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclasspdz<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclasspdz<T, U, V>, 

VFPCLASSPDZ instruction

Instruction	Opcode	CPUID
VFPCLASSPD k2 {k1}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 66 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclassph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclassph<T, U, V>, 

VFPCLASSPH instruction

Instruction	Opcode	CPUID
VFPCLASSPH k1 {k2}, xmm2/m128/m16bcst, imm8	EVEX.128.0F3A.W0 66 /r ib	AVX512VL AVX512-FP16
VFPCLASSPH k1 {k2}, ymm2/m256/m16bcst, imm8	EVEX.256.0F3A.W0 66 /r ib	AVX512VL AVX512-FP16
VFPCLASSPH k1 {k2}, zmm2/m512/m16bcst, imm8	EVEX.512.0F3A.W0 66 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclassphx<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclassphx<T, U, V>, 

VFPCLASSPHX instruction

Instruction	Opcode	CPUID
VFPCLASSPH k1 {k2}, xmm2/m128/m16bcst, imm8	EVEX.128.0F3A.W0 66 /r ib	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclassphy<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclassphy<T, U, V>, 

VFPCLASSPHY instruction

Instruction	Opcode	CPUID
VFPCLASSPH k1 {k2}, ymm2/m256/m16bcst, imm8	EVEX.256.0F3A.W0 66 /r ib	AVX512VL AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclassphz<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclassphz<T, U, V>, 

VFPCLASSPHZ instruction

Instruction	Opcode	CPUID
VFPCLASSPH k1 {k2}, zmm2/m512/m16bcst, imm8	EVEX.512.0F3A.W0 66 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclassps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclassps<T, U, V>, 

VFPCLASSPS instruction

Instruction	Opcode	CPUID
VFPCLASSPS k2 {k1}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 66 /r ib	AVX512VL AVX512DQ
VFPCLASSPS k2 {k1}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 66 /r ib	AVX512VL AVX512DQ
VFPCLASSPS k2 {k1}, zmm2/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 66 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclasspsx<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclasspsx<T, U, V>, 

VFPCLASSPSX instruction

Instruction	Opcode	CPUID
VFPCLASSPS k2 {k1}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 66 /r ib	AVX512VL AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclasspsy<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclasspsy<T, U, V>, 

VFPCLASSPSY instruction

Instruction	Opcode	CPUID
VFPCLASSPS k2 {k1}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 66 /r ib	AVX512VL AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclasspsz<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclasspsz<T, U, V>, 

VFPCLASSPSZ instruction

Instruction	Opcode	CPUID
VFPCLASSPS k2 {k1}, zmm2/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 66 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclasssd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclasssd<T, U, V>, 

VFPCLASSSD instruction

Instruction	Opcode	CPUID
VFPCLASSSD k2 {k1}, xmm2/m64, imm8	EVEX.LIG.66.0F3A.W1 67 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclasssh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclasssh<T, U, V>, 

VFPCLASSSH instruction

Instruction	Opcode	CPUID
VFPCLASSSH k1 {k2}, xmm2/m16, imm8	EVEX.LIG.0F3A.W0 67 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfpclassss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVfpclassss<T, U, V>, 

VFPCLASSSS instruction

Instruction	Opcode	CPUID
VFPCLASSSS k2 {k1}, xmm2/m32, imm8	EVEX.LIG.66.0F3A.W0 67 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vfrczpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVfrczpd<T, U>, 

VFRCZPD instruction

Instruction	Opcode	CPUID
VFRCZPD xmm1, xmm2/m128	XOP.128.X9.W0 81 /r	XOP
VFRCZPD ymm1, ymm2/m256	XOP.256.X9.W0 81 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vfrczps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVfrczps<T, U>, 

VFRCZPS instruction

Instruction	Opcode	CPUID
VFRCZPS xmm1, xmm2/m128	XOP.128.X9.W0 80 /r	XOP
VFRCZPS ymm1, ymm2/m256	XOP.256.X9.W0 80 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vfrczsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVfrczsd<T, U>, 

VFRCZSD instruction

Instruction	Opcode	CPUID
VFRCZSD xmm1, xmm2/m64	XOP.128.X9.W0 83 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vfrczss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVfrczss<T, U>, 

VFRCZSS instruction

Instruction	Opcode	CPUID
VFRCZSS xmm1, xmm2/m32	XOP.128.X9.W0 82 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vgatherdpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVgatherdpd<T, U>, 

VGATHERDPD instruction

Instruction	Opcode	CPUID
VGATHERDPD xmm1 {k1}, vm32x	EVEX.128.66.0F38.W1 92 /vsib	AVX512VL AVX512F
VGATHERDPD ymm1 {k1}, vm32x	EVEX.256.66.0F38.W1 92 /vsib	AVX512VL AVX512F
VGATHERDPD zmm1 {k1}, vm32y	EVEX.512.66.0F38.W1 92 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vgatherdpd_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgatherdpd3<T, U, V>, 

VGATHERDPD instruction

Instruction	Opcode	CPUID
VGATHERDPD xmm1, vm32x, xmm2	VEX.128.66.0F38.W1 92 /r	AVX2
VGATHERDPD ymm1, vm32x, ymm2	VEX.256.66.0F38.W1 92 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgatherdps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVgatherdps<T, U>, 

VGATHERDPS instruction

Instruction	Opcode	CPUID
VGATHERDPS xmm1 {k1}, vm32x	EVEX.128.66.0F38.W0 92 /vsib	AVX512VL AVX512F
VGATHERDPS ymm1 {k1}, vm32y	EVEX.256.66.0F38.W0 92 /vsib	AVX512VL AVX512F
VGATHERDPS zmm1 {k1}, vm32z	EVEX.512.66.0F38.W0 92 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vgatherdps_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgatherdps3<T, U, V>, 

VGATHERDPS instruction

Instruction	Opcode	CPUID
VGATHERDPS xmm1, vm32x, xmm2	VEX.128.66.0F38.W0 92 /r	AVX2
VGATHERDPS ymm1, vm32y, ymm2	VEX.256.66.0F38.W0 92 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgatherpf0dpd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVgatherpf0dpd<T>, 

VGATHERPF0DPD instruction

Instruction	Opcode	CPUID
VGATHERPF0DPD vm32y {k1}	EVEX.512.66.0F38.W1 C6 /1 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vgatherpf0dps<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVgatherpf0dps<T>, 

VGATHERPF0DPS instruction

Instruction	Opcode	CPUID
VGATHERPF0DPS vm32z {k1}	EVEX.512.66.0F38.W0 C6 /1 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vgatherpf0qpd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVgatherpf0qpd<T>, 

VGATHERPF0QPD instruction

Instruction	Opcode	CPUID
VGATHERPF0QPD vm64z {k1}	EVEX.512.66.0F38.W1 C7 /1 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vgatherpf0qps<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVgatherpf0qps<T>, 

VGATHERPF0QPS instruction

Instruction	Opcode	CPUID
VGATHERPF0QPS vm64z {k1}	EVEX.512.66.0F38.W0 C7 /1 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vgatherpf1dpd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVgatherpf1dpd<T>, 

VGATHERPF1DPD instruction

Instruction	Opcode	CPUID
VGATHERPF1DPD vm32y {k1}	EVEX.512.66.0F38.W1 C6 /2 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vgatherpf1dps<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVgatherpf1dps<T>, 

VGATHERPF1DPS instruction

Instruction	Opcode	CPUID
VGATHERPF1DPS vm32z {k1}	EVEX.512.66.0F38.W0 C6 /2 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vgatherpf1qpd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVgatherpf1qpd<T>, 

VGATHERPF1QPD instruction

Instruction	Opcode	CPUID
VGATHERPF1QPD vm64z {k1}	EVEX.512.66.0F38.W1 C7 /2 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vgatherpf1qps<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVgatherpf1qps<T>, 

VGATHERPF1QPS instruction

Instruction	Opcode	CPUID
VGATHERPF1QPS vm64z {k1}	EVEX.512.66.0F38.W0 C7 /2 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vgatherqpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVgatherqpd<T, U>, 

VGATHERQPD instruction

Instruction	Opcode	CPUID
VGATHERQPD xmm1 {k1}, vm64x	EVEX.128.66.0F38.W1 93 /vsib	AVX512VL AVX512F
VGATHERQPD ymm1 {k1}, vm64y	EVEX.256.66.0F38.W1 93 /vsib	AVX512VL AVX512F
VGATHERQPD zmm1 {k1}, vm64z	EVEX.512.66.0F38.W1 93 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vgatherqpd_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgatherqpd3<T, U, V>, 

VGATHERQPD instruction

Instruction	Opcode	CPUID
VGATHERQPD xmm1, vm64x, xmm2	VEX.128.66.0F38.W1 93 /r	AVX2
VGATHERQPD ymm1, vm64y, ymm2	VEX.256.66.0F38.W1 93 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgatherqps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVgatherqps<T, U>, 

VGATHERQPS instruction

Instruction	Opcode	CPUID
VGATHERQPS xmm1 {k1}, vm64x	EVEX.128.66.0F38.W0 93 /vsib	AVX512VL AVX512F
VGATHERQPS xmm1 {k1}, vm64y	EVEX.256.66.0F38.W0 93 /vsib	AVX512VL AVX512F
VGATHERQPS ymm1 {k1}, vm64z	EVEX.512.66.0F38.W0 93 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vgatherqps_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgatherqps3<T, U, V>, 

VGATHERQPS instruction

Instruction	Opcode	CPUID
VGATHERQPS xmm1, vm64x, xmm2	VEX.128.66.0F38.W0 93 /r	AVX2
VGATHERQPS xmm1, vm64y, xmm2	VEX.256.66.0F38.W0 93 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgetexppd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVgetexppd<T, U>, 

VGETEXPPD instruction

Instruction	Opcode	CPUID
VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F38.W1 42 /r	AVX512VL AVX512F
VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F38.W1 42 /r	AVX512VL AVX512F
VGETEXPPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}	EVEX.512.66.0F38.W1 42 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vgetexpph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVgetexpph<T, U>, 

VGETEXPPH instruction

Instruction	Opcode	CPUID
VGETEXPPH xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.66.MAP6.W0 42 /r	AVX512VL AVX512-FP16
VGETEXPPH ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.66.MAP6.W0 42 /r	AVX512VL AVX512-FP16
VGETEXPPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}	EVEX.512.66.MAP6.W0 42 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vgetexpps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVgetexpps<T, U>, 

VGETEXPPS instruction

Instruction	Opcode	CPUID
VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.0F38.W0 42 /r	AVX512VL AVX512F
VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.0F38.W0 42 /r	AVX512VL AVX512F
VGETEXPPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}	EVEX.512.66.0F38.W0 42 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vgetexpsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgetexpsd<T, U, V>, 

VGETEXPSD instruction

Instruction	Opcode	CPUID
VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}	EVEX.LIG.66.0F38.W1 43 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgetexpsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgetexpsh<T, U, V>, 

VGETEXPSH instruction

Instruction	Opcode	CPUID
VGETEXPSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}	EVEX.LIG.66.MAP6.W0 43 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgetexpss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgetexpss<T, U, V>, 

VGETEXPSS instruction

Instruction	Opcode	CPUID
VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}	EVEX.LIG.66.0F38.W0 43 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgetmantpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgetmantpd<T, U, V>, 

VGETMANTPD instruction

Instruction	Opcode	CPUID
VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 26 /r ib	AVX512VL AVX512F
VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 26 /r ib	AVX512VL AVX512F
VGETMANTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8	EVEX.512.66.0F3A.W1 26 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgetmantph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgetmantph<T, U, V>, 

VGETMANTPH instruction

Instruction	Opcode	CPUID
VGETMANTPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8	EVEX.128.0F3A.W0 26 /r ib	AVX512VL AVX512-FP16
VGETMANTPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8	EVEX.256.0F3A.W0 26 /r ib	AVX512VL AVX512-FP16
VGETMANTPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 26 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgetmantps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgetmantps<T, U, V>, 

VGETMANTPS instruction

Instruction	Opcode	CPUID
VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 26 /r ib	AVX512VL AVX512F
VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 26 /r ib	AVX512VL AVX512F
VGETMANTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8	EVEX.512.66.0F3A.W0 26 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vgetmantsd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVgetmantsd<T, U, V, W>, 

VGETMANTSD instruction

Instruction	Opcode	CPUID
VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.66.0F3A.W1 27 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vgetmantsh<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVgetmantsh<T, U, V, W>, 

VGETMANTSH instruction

Instruction	Opcode	CPUID
VGETMANTSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.0F3A.W0 27 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vgetmantss<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVgetmantss<T, U, V, W>, 

VGETMANTSS instruction

Instruction	Opcode	CPUID
VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.66.0F3A.W0 27 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vgf2p8affineinvqb<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVgf2p8affineinvqb<T, U, V, W>, 

VGF2P8AFFINEINVQB instruction

Instruction	Opcode	CPUID
VGF2P8AFFINEINVQB xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.W1 CF /r ib	AVX GFNI
VGF2P8AFFINEINVQB ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.W1 CF /r ib	AVX GFNI
VGF2P8AFFINEINVQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 CF /r ib	AVX512VL GFNI
VGF2P8AFFINEINVQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 CF /r ib	AVX512VL GFNI
VGF2P8AFFINEINVQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 CF /r ib	AVX512F GFNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vgf2p8affineqb<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVgf2p8affineqb<T, U, V, W>, 

VGF2P8AFFINEQB instruction

Instruction	Opcode	CPUID
VGF2P8AFFINEQB xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.W1 CE /r ib	AVX GFNI
VGF2P8AFFINEQB ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.W1 CE /r ib	AVX GFNI
VGF2P8AFFINEQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 CE /r ib	AVX512VL GFNI
VGF2P8AFFINEQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 CE /r ib	AVX512VL GFNI
VGF2P8AFFINEQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 CE /r ib	AVX512F GFNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vgf2p8mulb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVgf2p8mulb<T, U, V>, 

VGF2P8MULB instruction

Instruction	Opcode	CPUID
VGF2P8MULB xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 CF /r	AVX GFNI
VGF2P8MULB ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 CF /r	AVX GFNI
VGF2P8MULB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W0 CF /r	AVX512VL GFNI
VGF2P8MULB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W0 CF /r	AVX512VL GFNI
VGF2P8MULB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W0 CF /r	AVX512F GFNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vhaddpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVhaddpd<T, U, V>, 

VHADDPD instruction

Instruction	Opcode	CPUID
VHADDPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 7C /r	AVX
VHADDPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 7C /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vhaddps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVhaddps<T, U, V>, 

VHADDPS instruction

Instruction	Opcode	CPUID
VHADDPS xmm1, xmm2, xmm3/m128	VEX.128.F2.0F.WIG 7C /r	AVX
VHADDPS ymm1, ymm2, ymm3/m256	VEX.256.F2.0F.WIG 7C /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vhsubpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVhsubpd<T, U, V>, 

VHSUBPD instruction

Instruction	Opcode	CPUID
VHSUBPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 7D /r	AVX
VHSUBPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 7D /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vhsubps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVhsubps<T, U, V>, 

VHSUBPS instruction

Instruction	Opcode	CPUID
VHSUBPS xmm1, xmm2, xmm3/m128	VEX.128.F2.0F.WIG 7D /r	AVX
VHSUBPS ymm1, ymm2, ymm3/m256	VEX.256.F2.0F.WIG 7D /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vinsertf128<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinsertf128<T, U, V, W>, 

VINSERTF128 instruction

Instruction	Opcode	CPUID
VINSERTF128 ymm1, ymm2, xmm3/m128, imm8	VEX.256.66.0F3A.W0 18 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinsertf32x4<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinsertf32x4<T, U, V, W>, 

VINSERTF32X4 instruction

Instruction	Opcode	CPUID
VINSERTF32X4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8	EVEX.256.66.0F3A.W0 18 /r ib	AVX512VL AVX512F
VINSERTF32X4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8	EVEX.512.66.0F3A.W0 18 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinsertf32x8<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinsertf32x8<T, U, V, W>, 

VINSERTF32X8 instruction

Instruction	Opcode	CPUID
VINSERTF32X8 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8	EVEX.512.66.0F3A.W0 1A /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinsertf64x2<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinsertf64x2<T, U, V, W>, 

VINSERTF64X2 instruction

Instruction	Opcode	CPUID
VINSERTF64X2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8	EVEX.256.66.0F3A.W1 18 /r ib	AVX512VL AVX512DQ
VINSERTF64X2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8	EVEX.512.66.0F3A.W1 18 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinsertf64x4<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinsertf64x4<T, U, V, W>, 

VINSERTF64X4 instruction

Instruction	Opcode	CPUID
VINSERTF64X4 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8	EVEX.512.66.0F3A.W1 1A /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinserti128<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinserti128<T, U, V, W>, 

VINSERTI128 instruction

Instruction	Opcode	CPUID
VINSERTI128 ymm1, ymm2, xmm3/m128, imm8	VEX.256.66.0F3A.W0 38 /r ib	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinserti32x4<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinserti32x4<T, U, V, W>, 

VINSERTI32X4 instruction

Instruction	Opcode	CPUID
VINSERTI32X4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8	EVEX.256.66.0F3A.W0 38 /r ib	AVX512VL AVX512F
VINSERTI32X4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8	EVEX.512.66.0F3A.W0 38 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinserti32x8<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinserti32x8<T, U, V, W>, 

VINSERTI32X8 instruction

Instruction	Opcode	CPUID
VINSERTI32X8 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8	EVEX.512.66.0F3A.W0 3A /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinserti64x2<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinserti64x2<T, U, V, W>, 

VINSERTI64X2 instruction

Instruction	Opcode	CPUID
VINSERTI64X2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8	EVEX.256.66.0F3A.W1 38 /r ib	AVX512VL AVX512DQ
VINSERTI64X2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8	EVEX.512.66.0F3A.W1 38 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinserti64x4<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinserti64x4<T, U, V, W>, 

VINSERTI64X4 instruction

Instruction	Opcode	CPUID
VINSERTI64X4 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8	EVEX.512.66.0F3A.W1 3A /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vinsertps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVinsertps<T, U, V, W>, 

VINSERTPS instruction

Instruction	Opcode	CPUID
VINSERTPS xmm1, xmm2, xmm3/m32, imm8	VEX.128.66.0F3A.WIG 21 /r ib	AVX
VINSERTPS xmm1, xmm2, xmm3/m32, imm8	EVEX.128.66.0F3A.W0 21 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vlddqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVlddqu<T, U>, 

VLDDQU instruction

Instruction	Opcode	CPUID
VLDDQU xmm1, m128	VEX.128.F2.0F.WIG F0 /r	AVX
VLDDQU ymm1, m256	VEX.256.F2.0F.WIG F0 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vldmxcsr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVldmxcsr<T>, 

VLDMXCSR instruction

Instruction	Opcode	CPUID
VLDMXCSR m32	VEX.LZ.0F.WIG AE /2	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vmaskmovdqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmaskmovdqu<T, U>, 

VMASKMOVDQU instruction

Instruction	Opcode	CPUID
VMASKMOVDQU xmm1, xmm2	VEX.128.66.0F.WIG F7 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmaskmovpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmaskmovpd<T, U, V>, 

VMASKMOVPD instruction

Instruction	Opcode	CPUID
VMASKMOVPD xmm1, xmm2, m128	VEX.128.66.0F38.W0 2D /r	AVX
VMASKMOVPD ymm1, ymm2, m256	VEX.256.66.0F38.W0 2D /r	AVX
VMASKMOVPD m128, xmm1, xmm2	VEX.128.66.0F38.W0 2F /r	AVX
VMASKMOVPD m256, ymm1, ymm2	VEX.256.66.0F38.W0 2F /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmaskmovps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmaskmovps<T, U, V>, 

VMASKMOVPS instruction

Instruction	Opcode	CPUID
VMASKMOVPS xmm1, xmm2, m128	VEX.128.66.0F38.W0 2C /r	AVX
VMASKMOVPS ymm1, ymm2, m256	VEX.256.66.0F38.W0 2C /r	AVX
VMASKMOVPS m128, xmm1, xmm2	VEX.128.66.0F38.W0 2E /r	AVX
VMASKMOVPS m256, ymm1, ymm2	VEX.256.66.0F38.W0 2E /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmaxpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmaxpd<T, U, V>, 

VMAXPD instruction

Instruction	Opcode	CPUID
VMAXPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 5F /r	AVX
VMAXPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 5F /r	AVX
VMAXPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 5F /r	AVX512VL AVX512F
VMAXPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 5F /r	AVX512VL AVX512F
VMAXPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}	EVEX.512.66.0F.W1 5F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmaxph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmaxph<T, U, V>, 

VMAXPH instruction

Instruction	Opcode	CPUID
VMAXPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.MAP5.W0 5F /r	AVX512VL AVX512-FP16
VMAXPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.MAP5.W0 5F /r	AVX512VL AVX512-FP16
VMAXPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{sae}	EVEX.512.MAP5.W0 5F /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmaxps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmaxps<T, U, V>, 

VMAXPS instruction

Instruction	Opcode	CPUID
VMAXPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 5F /r	AVX
VMAXPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 5F /r	AVX
VMAXPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 5F /r	AVX512VL AVX512F
VMAXPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 5F /r	AVX512VL AVX512F
VMAXPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}	EVEX.512.0F.W0 5F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmaxsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmaxsd<T, U, V>, 

VMAXSD instruction

Instruction	Opcode	CPUID
VMAXSD xmm1, xmm2, xmm3/m64	VEX.LIG.F2.0F.WIG 5F /r	AVX
VMAXSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}	EVEX.LIG.F2.0F.W1 5F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmaxsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmaxsh<T, U, V>, 

VMAXSH instruction

Instruction	Opcode	CPUID
VMAXSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}	EVEX.LIG.F3.MAP5.W0 5F /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmaxss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmaxss<T, U, V>, 

VMAXSS instruction

Instruction	Opcode	CPUID
VMAXSS xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 5F /r	AVX
VMAXSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}	EVEX.LIG.F3.0F.W0 5F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmcall(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmcall, 

VMCALL instruction

Instruction	Opcode	CPUID
VMCALL	NP 0F 01 C1	VMX

Errors

Fails if an operand is invalid (basic checks only)

pub fn vmclear<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVmclear<T>, 

VMCLEAR instruction

Instruction	Opcode	CPUID
VMCLEAR m64	66 0F C7 /6	VMX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vmfunc(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmfunc, 

VMFUNC instruction

Instruction	Opcode	CPUID
VMFUNC	NP 0F 01 D4	VMX

Errors

Fails if an operand is invalid (basic checks only)

pub fn vmgexit(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmgexit, 

VMGEXIT instruction

Instruction	Opcode	CPUID
VMGEXIT	F3 0F 01 D9	SEV-ES

Errors

Fails if an operand is invalid (basic checks only)

pub fn vminpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVminpd<T, U, V>, 

VMINPD instruction

Instruction	Opcode	CPUID
VMINPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 5D /r	AVX
VMINPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 5D /r	AVX
VMINPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 5D /r	AVX512VL AVX512F
VMINPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 5D /r	AVX512VL AVX512F
VMINPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}	EVEX.512.66.0F.W1 5D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vminph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVminph<T, U, V>, 

VMINPH instruction

Instruction	Opcode	CPUID
VMINPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.MAP5.W0 5D /r	AVX512VL AVX512-FP16
VMINPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.MAP5.W0 5D /r	AVX512VL AVX512-FP16
VMINPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{sae}	EVEX.512.MAP5.W0 5D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vminps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVminps<T, U, V>, 

VMINPS instruction

Instruction	Opcode	CPUID
VMINPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 5D /r	AVX
VMINPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 5D /r	AVX
VMINPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 5D /r	AVX512VL AVX512F
VMINPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 5D /r	AVX512VL AVX512F
VMINPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}	EVEX.512.0F.W0 5D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vminsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVminsd<T, U, V>, 

VMINSD instruction

Instruction	Opcode	CPUID
VMINSD xmm1, xmm2, xmm3/m64	VEX.LIG.F2.0F.WIG 5D /r	AVX
VMINSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}	EVEX.LIG.F2.0F.W1 5D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vminsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVminsh<T, U, V>, 

VMINSH instruction

Instruction	Opcode	CPUID
VMINSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}	EVEX.LIG.F3.MAP5.W0 5D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vminss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVminss<T, U, V>, 

VMINSS instruction

Instruction	Opcode	CPUID
VMINSS xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 5D /r	AVX
VMINSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}	EVEX.LIG.F3.0F.W0 5D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmlaunch(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmlaunch, 

VMLAUNCH instruction

Instruction	Opcode	CPUID
VMLAUNCH	NP 0F 01 C2	VMX

Errors

Fails if an operand is invalid (basic checks only)

pub fn vmload(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmload, 

VMLOAD instruction

Instruction	Opcode	CPUID
VMLOAD	a16 0F 01 DA	SVM
VMLOAD	a32 0F 01 DA	SVM
VMLOAD	a64 0F 01 DA	SVM

Errors

Fails if an operand is invalid (basic checks only)

pub fn vmmcall(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmmcall, 

VMMCALL instruction

Instruction	Opcode	CPUID
VMMCALL	0F 01 D9	SVM

Errors

Fails if an operand is invalid (basic checks only)

pub fn vmovapd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovapd<T, U>, 

VMOVAPD instruction

Instruction	Opcode	CPUID
VMOVAPD xmm1, xmm2/m128	VEX.128.66.0F.WIG 28 /r	AVX
VMOVAPD ymm1, ymm2/m256	VEX.256.66.0F.WIG 28 /r	AVX
VMOVAPD xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F.W1 28 /r	AVX512VL AVX512F
VMOVAPD ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F.W1 28 /r	AVX512VL AVX512F
VMOVAPD zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F.W1 28 /r	AVX512F
VMOVAPD xmm2/m128, xmm1	VEX.128.66.0F.WIG 29 /r	AVX
VMOVAPD ymm2/m256, ymm1	VEX.256.66.0F.WIG 29 /r	AVX
VMOVAPD xmm2/m128 {k1}{z}, xmm1	EVEX.128.66.0F.W1 29 /r	AVX512VL AVX512F
VMOVAPD ymm2/m256 {k1}{z}, ymm1	EVEX.256.66.0F.W1 29 /r	AVX512VL AVX512F
VMOVAPD zmm2/m512 {k1}{z}, zmm1	EVEX.512.66.0F.W1 29 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovaps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovaps<T, U>, 

VMOVAPS instruction

Instruction	Opcode	CPUID
VMOVAPS xmm1, xmm2/m128	VEX.128.0F.WIG 28 /r	AVX
VMOVAPS ymm1, ymm2/m256	VEX.256.0F.WIG 28 /r	AVX
VMOVAPS xmm1 {k1}{z}, xmm2/m128	EVEX.128.0F.W0 28 /r	AVX512VL AVX512F
VMOVAPS ymm1 {k1}{z}, ymm2/m256	EVEX.256.0F.W0 28 /r	AVX512VL AVX512F
VMOVAPS zmm1 {k1}{z}, zmm2/m512	EVEX.512.0F.W0 28 /r	AVX512F
VMOVAPS xmm2/m128, xmm1	VEX.128.0F.WIG 29 /r	AVX
VMOVAPS ymm2/m256, ymm1	VEX.256.0F.WIG 29 /r	AVX
VMOVAPS xmm2/m128 {k1}{z}, xmm1	EVEX.128.0F.W0 29 /r	AVX512VL AVX512F
VMOVAPS ymm2/m256 {k1}{z}, ymm1	EVEX.256.0F.W0 29 /r	AVX512VL AVX512F
VMOVAPS zmm2/m512 {k1}{z}, zmm1	EVEX.512.0F.W0 29 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovd<T, U>, 

VMOVD instruction

Instruction	Opcode	CPUID
VMOVD xmm1, r/m32	VEX.128.66.0F.W0 6E /r	AVX
VMOVD xmm1, r/m32	EVEX.128.66.0F.W0 6E /r	AVX512F
VMOVD r/m32, xmm1	VEX.128.66.0F.W0 7E /r	AVX
VMOVD r/m32, xmm1	EVEX.128.66.0F.W0 7E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovddup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovddup<T, U>, 

VMOVDDUP instruction

Instruction	Opcode	CPUID
VMOVDDUP xmm1, xmm2/m64	VEX.128.F2.0F.WIG 12 /r	AVX
VMOVDDUP ymm1, ymm2/m256	VEX.256.F2.0F.WIG 12 /r	AVX
VMOVDDUP xmm1 {k1}{z}, xmm2/m64	EVEX.128.F2.0F.W1 12 /r	AVX512VL AVX512F
VMOVDDUP ymm1 {k1}{z}, ymm2/m256	EVEX.256.F2.0F.W1 12 /r	AVX512VL AVX512F
VMOVDDUP zmm1 {k1}{z}, zmm2/m512	EVEX.512.F2.0F.W1 12 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovdqa<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovdqa<T, U>, 

VMOVDQA instruction

Instruction	Opcode	CPUID
VMOVDQA xmm1, xmm2/m128	VEX.128.66.0F.WIG 6F /r	AVX
VMOVDQA ymm1, ymm2/m256	VEX.256.66.0F.WIG 6F /r	AVX
VMOVDQA xmm2/m128, xmm1	VEX.128.66.0F.WIG 7F /r	AVX
VMOVDQA ymm2/m256, ymm1	VEX.256.66.0F.WIG 7F /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovdqa32<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovdqa32<T, U>, 

VMOVDQA32 instruction

Instruction	Opcode	CPUID
VMOVDQA32 xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F.W0 6F /r	AVX512VL AVX512F
VMOVDQA32 ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F.W0 6F /r	AVX512VL AVX512F
VMOVDQA32 zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F.W0 6F /r	AVX512F
VMOVDQA32 xmm2/m128 {k1}{z}, xmm1	EVEX.128.66.0F.W0 7F /r	AVX512VL AVX512F
VMOVDQA32 ymm2/m256 {k1}{z}, ymm1	EVEX.256.66.0F.W0 7F /r	AVX512VL AVX512F
VMOVDQA32 zmm2/m512 {k1}{z}, zmm1	EVEX.512.66.0F.W0 7F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovdqa64<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovdqa64<T, U>, 

VMOVDQA64 instruction

Instruction	Opcode	CPUID
VMOVDQA64 xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F.W1 6F /r	AVX512VL AVX512F
VMOVDQA64 ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F.W1 6F /r	AVX512VL AVX512F
VMOVDQA64 zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F.W1 6F /r	AVX512F
VMOVDQA64 xmm2/m128 {k1}{z}, xmm1	EVEX.128.66.0F.W1 7F /r	AVX512VL AVX512F
VMOVDQA64 ymm2/m256 {k1}{z}, ymm1	EVEX.256.66.0F.W1 7F /r	AVX512VL AVX512F
VMOVDQA64 zmm2/m512 {k1}{z}, zmm1	EVEX.512.66.0F.W1 7F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovdqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovdqu<T, U>, 

VMOVDQU instruction

Instruction	Opcode	CPUID
VMOVDQU xmm1, xmm2/m128	VEX.128.F3.0F.WIG 6F /r	AVX
VMOVDQU ymm1, ymm2/m256	VEX.256.F3.0F.WIG 6F /r	AVX
VMOVDQU xmm2/m128, xmm1	VEX.128.F3.0F.WIG 7F /r	AVX
VMOVDQU ymm2/m256, ymm1	VEX.256.F3.0F.WIG 7F /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovdqu16<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovdqu16<T, U>, 

VMOVDQU16 instruction

Instruction	Opcode	CPUID
VMOVDQU16 xmm1 {k1}{z}, xmm2/m128	EVEX.128.F2.0F.W1 6F /r	AVX512VL AVX512BW
VMOVDQU16 ymm1 {k1}{z}, ymm2/m256	EVEX.256.F2.0F.W1 6F /r	AVX512VL AVX512BW
VMOVDQU16 zmm1 {k1}{z}, zmm2/m512	EVEX.512.F2.0F.W1 6F /r	AVX512BW
VMOVDQU16 xmm2/m128 {k1}{z}, xmm1	EVEX.128.F2.0F.W1 7F /r	AVX512VL AVX512BW
VMOVDQU16 ymm2/m256 {k1}{z}, ymm1	EVEX.256.F2.0F.W1 7F /r	AVX512VL AVX512BW
VMOVDQU16 zmm2/m512 {k1}{z}, zmm1	EVEX.512.F2.0F.W1 7F /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovdqu32<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovdqu32<T, U>, 

VMOVDQU32 instruction

Instruction	Opcode	CPUID
VMOVDQU32 xmm1 {k1}{z}, xmm2/m128	EVEX.128.F3.0F.W0 6F /r	AVX512VL AVX512F
VMOVDQU32 ymm1 {k1}{z}, ymm2/m256	EVEX.256.F3.0F.W0 6F /r	AVX512VL AVX512F
VMOVDQU32 zmm1 {k1}{z}, zmm2/m512	EVEX.512.F3.0F.W0 6F /r	AVX512F
VMOVDQU32 xmm2/m128 {k1}{z}, xmm1	EVEX.128.F3.0F.W0 7F /r	AVX512VL AVX512F
VMOVDQU32 ymm2/m256 {k1}{z}, ymm1	EVEX.256.F3.0F.W0 7F /r	AVX512VL AVX512F
VMOVDQU32 zmm2/m512 {k1}{z}, zmm1	EVEX.512.F3.0F.W0 7F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovdqu64<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovdqu64<T, U>, 

VMOVDQU64 instruction

Instruction	Opcode	CPUID
VMOVDQU64 xmm1 {k1}{z}, xmm2/m128	EVEX.128.F3.0F.W1 6F /r	AVX512VL AVX512F
VMOVDQU64 ymm1 {k1}{z}, ymm2/m256	EVEX.256.F3.0F.W1 6F /r	AVX512VL AVX512F
VMOVDQU64 zmm1 {k1}{z}, zmm2/m512	EVEX.512.F3.0F.W1 6F /r	AVX512F
VMOVDQU64 xmm2/m128 {k1}{z}, xmm1	EVEX.128.F3.0F.W1 7F /r	AVX512VL AVX512F
VMOVDQU64 ymm2/m256 {k1}{z}, ymm1	EVEX.256.F3.0F.W1 7F /r	AVX512VL AVX512F
VMOVDQU64 zmm2/m512 {k1}{z}, zmm1	EVEX.512.F3.0F.W1 7F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovdqu8<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovdqu8<T, U>, 

VMOVDQU8 instruction

Instruction	Opcode	CPUID
VMOVDQU8 xmm1 {k1}{z}, xmm2/m128	EVEX.128.F2.0F.W0 6F /r	AVX512VL AVX512BW
VMOVDQU8 ymm1 {k1}{z}, ymm2/m256	EVEX.256.F2.0F.W0 6F /r	AVX512VL AVX512BW
VMOVDQU8 zmm1 {k1}{z}, zmm2/m512	EVEX.512.F2.0F.W0 6F /r	AVX512BW
VMOVDQU8 xmm2/m128 {k1}{z}, xmm1	EVEX.128.F2.0F.W0 7F /r	AVX512VL AVX512BW
VMOVDQU8 ymm2/m256 {k1}{z}, ymm1	EVEX.256.F2.0F.W0 7F /r	AVX512VL AVX512BW
VMOVDQU8 zmm2/m512 {k1}{z}, zmm1	EVEX.512.F2.0F.W0 7F /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovhlps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmovhlps<T, U, V>, 

VMOVHLPS instruction

Instruction	Opcode	CPUID
VMOVHLPS xmm1, xmm2, xmm3	VEX.128.0F.WIG 12 /r	AVX
VMOVHLPS xmm1, xmm2, xmm3	EVEX.128.0F.W0 12 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmovhpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovhpd<T, U>, 

VMOVHPD instruction

Instruction	Opcode	CPUID
VMOVHPD m64, xmm1	VEX.128.66.0F.WIG 17 /r	AVX
VMOVHPD m64, xmm1	EVEX.128.66.0F.W1 17 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovhpd_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmovhpd3<T, U, V>, 

VMOVHPD instruction

Instruction	Opcode	CPUID
VMOVHPD xmm2, xmm1, m64	VEX.128.66.0F.WIG 16 /r	AVX
VMOVHPD xmm2, xmm1, m64	EVEX.128.66.0F.W1 16 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmovhps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovhps<T, U>, 

VMOVHPS instruction

Instruction	Opcode	CPUID
VMOVHPS m64, xmm1	VEX.128.0F.WIG 17 /r	AVX
VMOVHPS m64, xmm1	EVEX.128.0F.W0 17 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovhps_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmovhps3<T, U, V>, 

VMOVHPS instruction

Instruction	Opcode	CPUID
VMOVHPS xmm2, xmm1, m64	VEX.128.0F.WIG 16 /r	AVX
VMOVHPS xmm2, xmm1, m64	EVEX.128.0F.W0 16 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmovlhps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmovlhps<T, U, V>, 

VMOVLHPS instruction

Instruction	Opcode	CPUID
VMOVLHPS xmm1, xmm2, xmm3	VEX.128.0F.WIG 16 /r	AVX
VMOVLHPS xmm1, xmm2, xmm3	EVEX.128.0F.W0 16 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmovlpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovlpd<T, U>, 

VMOVLPD instruction

Instruction	Opcode	CPUID
VMOVLPD m64, xmm1	VEX.128.66.0F.WIG 13 /r	AVX
VMOVLPD m64, xmm1	EVEX.128.66.0F.W1 13 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovlpd_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmovlpd3<T, U, V>, 

VMOVLPD instruction

Instruction	Opcode	CPUID
VMOVLPD xmm2, xmm1, m64	VEX.128.66.0F.WIG 12 /r	AVX
VMOVLPD xmm2, xmm1, m64	EVEX.128.66.0F.W1 12 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmovlps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovlps<T, U>, 

VMOVLPS instruction

Instruction	Opcode	CPUID
VMOVLPS m64, xmm1	VEX.128.0F.WIG 13 /r	AVX
VMOVLPS m64, xmm1	EVEX.128.0F.W0 13 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovlps_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmovlps3<T, U, V>, 

VMOVLPS instruction

Instruction	Opcode	CPUID
VMOVLPS xmm2, xmm1, m64	VEX.128.0F.WIG 12 /r	AVX
VMOVLPS xmm2, xmm1, m64	EVEX.128.0F.W0 12 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmovmskpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovmskpd<T, U>, 

VMOVMSKPD instruction

Instruction	Opcode	CPUID
VMOVMSKPD r32, xmm2	VEX.128.66.0F.W0 50 /r	AVX
VMOVMSKPD r32, ymm2	VEX.256.66.0F.W0 50 /r	AVX
VMOVMSKPD r64, xmm2	VEX.128.66.0F.W1 50 /r	AVX
VMOVMSKPD r64, ymm2	VEX.256.66.0F.W1 50 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovmskps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovmskps<T, U>, 

VMOVMSKPS instruction

Instruction	Opcode	CPUID
VMOVMSKPS r32, xmm2	VEX.128.0F.W0 50 /r	AVX
VMOVMSKPS r32, ymm2	VEX.256.0F.W0 50 /r	AVX
VMOVMSKPS r64, xmm2	VEX.128.0F.W1 50 /r	AVX
VMOVMSKPS r64, ymm2	VEX.256.0F.W1 50 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovntdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovntdq<T, U>, 

VMOVNTDQ instruction

Instruction	Opcode	CPUID
VMOVNTDQ m128, xmm1	VEX.128.66.0F.WIG E7 /r	AVX
VMOVNTDQ m256, ymm1	VEX.256.66.0F.WIG E7 /r	AVX
VMOVNTDQ m128, xmm1	EVEX.128.66.0F.W0 E7 /r	AVX512VL AVX512F
VMOVNTDQ m256, ymm1	EVEX.256.66.0F.W0 E7 /r	AVX512VL AVX512F
VMOVNTDQ m512, zmm1	EVEX.512.66.0F.W0 E7 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovntdqa<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovntdqa<T, U>, 

VMOVNTDQA instruction

Instruction	Opcode	CPUID
VMOVNTDQA xmm1, m128	VEX.128.66.0F38.WIG 2A /r	AVX
VMOVNTDQA ymm1, m256	VEX.256.66.0F38.WIG 2A /r	AVX2
VMOVNTDQA xmm1, m128	EVEX.128.66.0F38.W0 2A /r	AVX512VL AVX512F
VMOVNTDQA ymm1, m256	EVEX.256.66.0F38.W0 2A /r	AVX512VL AVX512F
VMOVNTDQA zmm1, m512	EVEX.512.66.0F38.W0 2A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovntpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovntpd<T, U>, 

VMOVNTPD instruction

Instruction	Opcode	CPUID
VMOVNTPD m128, xmm1	VEX.128.66.0F.WIG 2B /r	AVX
VMOVNTPD m256, ymm1	VEX.256.66.0F.WIG 2B /r	AVX
VMOVNTPD m128, xmm1	EVEX.128.66.0F.W1 2B /r	AVX512VL AVX512F
VMOVNTPD m256, ymm1	EVEX.256.66.0F.W1 2B /r	AVX512VL AVX512F
VMOVNTPD m512, zmm1	EVEX.512.66.0F.W1 2B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovntps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovntps<T, U>, 

VMOVNTPS instruction

Instruction	Opcode	CPUID
VMOVNTPS m128, xmm1	VEX.128.0F.WIG 2B /r	AVX
VMOVNTPS m256, ymm1	VEX.256.0F.WIG 2B /r	AVX
VMOVNTPS m128, xmm1	EVEX.128.0F.W0 2B /r	AVX512VL AVX512F
VMOVNTPS m256, ymm1	EVEX.256.0F.W0 2B /r	AVX512VL AVX512F
VMOVNTPS m512, zmm1	EVEX.512.0F.W0 2B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovq<T, U>, 

VMOVQ instruction

Instruction	Opcode	CPUID
VMOVQ xmm1, r/m64	VEX.128.66.0F.W1 6E /r	AVX
VMOVQ xmm1, r/m64	EVEX.128.66.0F.W1 6E /r	AVX512F
VMOVQ r/m64, xmm1	VEX.128.66.0F.W1 7E /r	AVX
VMOVQ r/m64, xmm1	EVEX.128.66.0F.W1 7E /r	AVX512F
VMOVQ xmm1, xmm2/m64	VEX.128.F3.0F.WIG 7E /r	AVX
VMOVQ xmm1, xmm2/m64	EVEX.128.F3.0F.W1 7E /r	AVX512F
VMOVQ xmm1/m64, xmm2	VEX.128.66.0F.WIG D6 /r	AVX
VMOVQ xmm1/m64, xmm2	EVEX.128.66.0F.W1 D6 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovsd<T, U>, 

VMOVSD instruction

Instruction	Opcode	CPUID
VMOVSD xmm1, m64	VEX.LIG.F2.0F.WIG 10 /r	AVX
VMOVSD xmm1 {k1}{z}, m64	EVEX.LIG.F2.0F.W1 10 /r	AVX512F
VMOVSD m64, xmm1	VEX.LIG.F2.0F.WIG 11 /r	AVX
VMOVSD m64 {k1}, xmm1	EVEX.LIG.F2.0F.W1 11 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovsd_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmovsd3<T, U, V>, 

VMOVSD instruction

Instruction	Opcode	CPUID
VMOVSD xmm1, xmm2, xmm3	VEX.LIG.F2.0F.WIG 10 /r	AVX
VMOVSD xmm1 {k1}{z}, xmm2, xmm3	EVEX.LIG.F2.0F.W1 10 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmovsh<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovsh<T, U>, 

VMOVSH instruction

Instruction	Opcode	CPUID
VMOVSH xmm1 {k1}{z}, m16	EVEX.LIG.F3.MAP5.W0 10 /r	AVX512-FP16
VMOVSH m16 {k1}, xmm1	EVEX.LIG.F3.MAP5.W0 11 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovsh_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmovsh3<T, U, V>, 

VMOVSH instruction

Instruction	Opcode	CPUID
VMOVSH xmm1 {k1}{z}, xmm2, xmm3	EVEX.LIG.F3.MAP5.W0 10 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmovshdup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovshdup<T, U>, 

VMOVSHDUP instruction

Instruction	Opcode	CPUID
VMOVSHDUP xmm1, xmm2/m128	VEX.128.F3.0F.WIG 16 /r	AVX
VMOVSHDUP ymm1, ymm2/m256	VEX.256.F3.0F.WIG 16 /r	AVX
VMOVSHDUP xmm1 {k1}{z}, xmm2/m128	EVEX.128.F3.0F.W0 16 /r	AVX512VL AVX512F
VMOVSHDUP ymm1 {k1}{z}, ymm2/m256	EVEX.256.F3.0F.W0 16 /r	AVX512VL AVX512F
VMOVSHDUP zmm1 {k1}{z}, zmm2/m512	EVEX.512.F3.0F.W0 16 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovsldup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovsldup<T, U>, 

VMOVSLDUP instruction

Instruction	Opcode	CPUID
VMOVSLDUP xmm1, xmm2/m128	VEX.128.F3.0F.WIG 12 /r	AVX
VMOVSLDUP ymm1, ymm2/m256	VEX.256.F3.0F.WIG 12 /r	AVX
VMOVSLDUP xmm1 {k1}{z}, xmm2/m128	EVEX.128.F3.0F.W0 12 /r	AVX512VL AVX512F
VMOVSLDUP ymm1 {k1}{z}, ymm2/m256	EVEX.256.F3.0F.W0 12 /r	AVX512VL AVX512F
VMOVSLDUP zmm1 {k1}{z}, zmm2/m512	EVEX.512.F3.0F.W0 12 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovss<T, U>, 

VMOVSS instruction

Instruction	Opcode	CPUID
VMOVSS xmm1, m32	VEX.LIG.F3.0F.WIG 10 /r	AVX
VMOVSS xmm1 {k1}{z}, m32	EVEX.LIG.F3.0F.W0 10 /r	AVX512F
VMOVSS m32, xmm1	VEX.LIG.F3.0F.WIG 11 /r	AVX
VMOVSS m32 {k1}, xmm1	EVEX.LIG.F3.0F.W0 11 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovss_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmovss3<T, U, V>, 

VMOVSS instruction

Instruction	Opcode	CPUID
VMOVSS xmm1, xmm2, xmm3	VEX.LIG.F3.0F.WIG 10 /r	AVX
VMOVSS xmm1 {k1}{z}, xmm2, xmm3	EVEX.LIG.F3.0F.W0 10 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmovupd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovupd<T, U>, 

VMOVUPD instruction

Instruction	Opcode	CPUID
VMOVUPD xmm1, xmm2/m128	VEX.128.66.0F.WIG 10 /r	AVX
VMOVUPD ymm1, ymm2/m256	VEX.256.66.0F.WIG 10 /r	AVX
VMOVUPD xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F.W1 10 /r	AVX512VL AVX512F
VMOVUPD ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F.W1 10 /r	AVX512VL AVX512F
VMOVUPD zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F.W1 10 /r	AVX512F
VMOVUPD xmm2/m128, xmm1	VEX.128.66.0F.WIG 11 /r	AVX
VMOVUPD ymm2/m256, ymm1	VEX.256.66.0F.WIG 11 /r	AVX
VMOVUPD xmm2/m128 {k1}{z}, xmm1	EVEX.128.66.0F.W1 11 /r	AVX512VL AVX512F
VMOVUPD ymm2/m256 {k1}{z}, ymm1	EVEX.256.66.0F.W1 11 /r	AVX512VL AVX512F
VMOVUPD zmm2/m512 {k1}{z}, zmm1	EVEX.512.66.0F.W1 11 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovups<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovups<T, U>, 

VMOVUPS instruction

Instruction	Opcode	CPUID
VMOVUPS xmm1, xmm2/m128	VEX.128.0F.WIG 10 /r	AVX
VMOVUPS ymm1, ymm2/m256	VEX.256.0F.WIG 10 /r	AVX
VMOVUPS xmm1 {k1}{z}, xmm2/m128	EVEX.128.0F.W0 10 /r	AVX512VL AVX512F
VMOVUPS ymm1 {k1}{z}, ymm2/m256	EVEX.256.0F.W0 10 /r	AVX512VL AVX512F
VMOVUPS zmm1 {k1}{z}, zmm2/m512	EVEX.512.0F.W0 10 /r	AVX512F
VMOVUPS xmm2/m128, xmm1	VEX.128.0F.WIG 11 /r	AVX
VMOVUPS ymm2/m256, ymm1	VEX.256.0F.WIG 11 /r	AVX
VMOVUPS xmm2/m128 {k1}{z}, xmm1	EVEX.128.0F.W0 11 /r	AVX512VL AVX512F
VMOVUPS ymm2/m256 {k1}{z}, ymm1	EVEX.256.0F.W0 11 /r	AVX512VL AVX512F
VMOVUPS zmm2/m512 {k1}{z}, zmm1	EVEX.512.0F.W0 11 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmovw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmovw<T, U>, 

VMOVW instruction

Instruction	Opcode	CPUID
VMOVW xmm1, r32/m16	EVEX.128.66.MAP5.W0 6E /r	AVX512-FP16
VMOVW xmm1, r64/m16	EVEX.128.66.MAP5.W1 6E /r	AVX512-FP16
VMOVW r32/m16, xmm1	EVEX.128.66.MAP5.W0 7E /r	AVX512-FP16
VMOVW r64/m16, xmm1	EVEX.128.66.MAP5.W1 7E /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmpsadbw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVmpsadbw<T, U, V, W>, 

VMPSADBW instruction

Instruction	Opcode	CPUID
VMPSADBW xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 42 /r ib	AVX
VMPSADBW ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 42 /r ib	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vmptrld<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVmptrld<T>, 

VMPTRLD instruction

Instruction	Opcode	CPUID
VMPTRLD m64	NP 0F C7 /6	VMX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vmptrst<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVmptrst<T>, 

VMPTRST instruction

Instruction	Opcode	CPUID
VMPTRST m64	NP 0F C7 /7	VMX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vmread<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmread<T, U>, 

VMREAD instruction

Instruction	Opcode	CPUID
VMREAD r/m32, r32	NP 0F 78 /r	VMX
VMREAD r/m64, r64	NP 0F 78 /r	VMX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmresume(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmresume, 

VMRESUME instruction

Instruction	Opcode	CPUID
VMRESUME	NP 0F 01 C3	VMX

Errors

Fails if an operand is invalid (basic checks only)

pub fn vmrun(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmrun, 

VMRUN instruction

Instruction	Opcode	CPUID
VMRUN	a16 0F 01 D8	SVM
VMRUN	a32 0F 01 D8	SVM
VMRUN	a64 0F 01 D8	SVM

Errors

Fails if an operand is invalid (basic checks only)

pub fn vmsave(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmsave, 

VMSAVE instruction

Instruction	Opcode	CPUID
VMSAVE	a16 0F 01 DB	SVM
VMSAVE	a32 0F 01 DB	SVM
VMSAVE	a64 0F 01 DB	SVM

Errors

Fails if an operand is invalid (basic checks only)

pub fn vmulpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmulpd<T, U, V>, 

VMULPD instruction

Instruction	Opcode	CPUID
VMULPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 59 /r	AVX
VMULPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 59 /r	AVX
VMULPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 59 /r	AVX512VL AVX512F
VMULPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 59 /r	AVX512VL AVX512F
VMULPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F.W1 59 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmulph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmulph<T, U, V>, 

VMULPH instruction

Instruction	Opcode	CPUID
VMULPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.MAP5.W0 59 /r	AVX512VL AVX512-FP16
VMULPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.MAP5.W0 59 /r	AVX512VL AVX512-FP16
VMULPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.MAP5.W0 59 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmulps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmulps<T, U, V>, 

VMULPS instruction

Instruction	Opcode	CPUID
VMULPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 59 /r	AVX
VMULPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 59 /r	AVX
VMULPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 59 /r	AVX512VL AVX512F
VMULPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 59 /r	AVX512VL AVX512F
VMULPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.0F.W0 59 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmulsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmulsd<T, U, V>, 

VMULSD instruction

Instruction	Opcode	CPUID
VMULSD xmm1, xmm2, xmm3/m64	VEX.LIG.F2.0F.WIG 59 /r	AVX
VMULSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.F2.0F.W1 59 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmulsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmulsh<T, U, V>, 

VMULSH instruction

Instruction	Opcode	CPUID
VMULSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.F3.MAP5.W0 59 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmulss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVmulss<T, U, V>, 

VMULSS instruction

Instruction	Opcode	CPUID
VMULSS xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 59 /r	AVX
VMULSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.F3.0F.W0 59 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vmwrite<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVmwrite<T, U>, 

VMWRITE instruction

Instruction	Opcode	CPUID
VMWRITE r32, r/m32	NP 0F 79 /r	VMX
VMWRITE r64, r/m64	NP 0F 79 /r	VMX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vmxoff(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVmxoff, 

VMXOFF instruction

Instruction	Opcode	CPUID
VMXOFF	NP 0F 01 C4	VMX

Errors

Fails if an operand is invalid (basic checks only)

pub fn vmxon<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVmxon<T>, 

VMXON instruction

Instruction	Opcode	CPUID
VMXON m64	F3 0F C7 /6	VMX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vorpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVorpd<T, U, V>, 

VORPD instruction

Instruction	Opcode	CPUID
VORPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 56 /r	AVX
VORPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 56 /r	AVX
VORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 56 /r	AVX512VL AVX512DQ
VORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 56 /r	AVX512VL AVX512DQ
VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 56 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vorps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVorps<T, U, V>, 

VORPS instruction

Instruction	Opcode	CPUID
VORPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 56 /r	AVX
VORPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 56 /r	AVX
VORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 56 /r	AVX512VL AVX512DQ
VORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 56 /r	AVX512VL AVX512DQ
VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.0F.W0 56 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vp2intersectd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVp2intersectd<T, U, V>, 

VP2INTERSECTD instruction

Instruction	Opcode	CPUID
VP2INTERSECTD k1+1, xmm2, xmm3/m128/m32bcst	EVEX.128.F2.0F38.W0 68 /r	AVX512VL AVX512_VP2INTERSECT
VP2INTERSECTD k1+1, ymm2, ymm3/m256/m32bcst	EVEX.256.F2.0F38.W0 68 /r	AVX512VL AVX512_VP2INTERSECT
VP2INTERSECTD k1+1, zmm2, zmm3/m512/m32bcst	EVEX.512.F2.0F38.W0 68 /r	AVX512F AVX512_VP2INTERSECT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vp2intersectq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVp2intersectq<T, U, V>, 

VP2INTERSECTQ instruction

Instruction	Opcode	CPUID
VP2INTERSECTQ k1+1, xmm2, xmm3/m128/m64bcst	EVEX.128.F2.0F38.W1 68 /r	AVX512VL AVX512_VP2INTERSECT
VP2INTERSECTQ k1+1, ymm2, ymm3/m256/m64bcst	EVEX.256.F2.0F38.W1 68 /r	AVX512VL AVX512_VP2INTERSECT
VP2INTERSECTQ k1+1, zmm2, zmm3/m512/m64bcst	EVEX.512.F2.0F38.W1 68 /r	AVX512F AVX512_VP2INTERSECT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vp4dpwssd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVp4dpwssd<T, U, V>, 

VP4DPWSSD instruction

Instruction	Opcode	CPUID
VP4DPWSSD zmm1 {k1}{z}, zmm2+3, m128	EVEX.512.F2.0F38.W0 52 /r	AVX512_4VNNIW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vp4dpwssds<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVp4dpwssds<T, U, V>, 

VP4DPWSSDS instruction

Instruction	Opcode	CPUID
VP4DPWSSDS zmm1 {k1}{z}, zmm2+3, m128	EVEX.512.F2.0F38.W0 53 /r	AVX512_4VNNIW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpabsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpabsb<T, U>, 

VPABSB instruction

Instruction	Opcode	CPUID
VPABSB xmm1, xmm2/m128	VEX.128.66.0F38.WIG 1C /r	AVX
VPABSB ymm1, ymm2/m256	VEX.256.66.0F38.WIG 1C /r	AVX2
VPABSB xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.WIG 1C /r	AVX512VL AVX512BW
VPABSB ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.WIG 1C /r	AVX512VL AVX512BW
VPABSB zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.WIG 1C /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpabsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpabsd<T, U>, 

VPABSD instruction

Instruction	Opcode	CPUID
VPABSD xmm1, xmm2/m128	VEX.128.66.0F38.WIG 1E /r	AVX
VPABSD ymm1, ymm2/m256	VEX.256.66.0F38.WIG 1E /r	AVX2
VPABSD xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.0F38.W0 1E /r	AVX512VL AVX512F
VPABSD ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.0F38.W0 1E /r	AVX512VL AVX512F
VPABSD zmm1 {k1}{z}, zmm2/m512/m32bcst	EVEX.512.66.0F38.W0 1E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpabsq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpabsq<T, U>, 

VPABSQ instruction

Instruction	Opcode	CPUID
VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F38.W1 1F /r	AVX512VL AVX512F
VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F38.W1 1F /r	AVX512VL AVX512F
VPABSQ zmm1 {k1}{z}, zmm2/m512/m64bcst	EVEX.512.66.0F38.W1 1F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpabsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpabsw<T, U>, 

VPABSW instruction

Instruction	Opcode	CPUID
VPABSW xmm1, xmm2/m128	VEX.128.66.0F38.WIG 1D /r	AVX
VPABSW ymm1, ymm2/m256	VEX.256.66.0F38.WIG 1D /r	AVX2
VPABSW xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.WIG 1D /r	AVX512VL AVX512BW
VPABSW ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.WIG 1D /r	AVX512VL AVX512BW
VPABSW zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.WIG 1D /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpackssdw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpackssdw<T, U, V>, 

VPACKSSDW instruction

Instruction	Opcode	CPUID
VPACKSSDW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 6B /r	AVX
VPACKSSDW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 6B /r	AVX2
VPACKSSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 6B /r	AVX512VL AVX512BW
VPACKSSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 6B /r	AVX512VL AVX512BW
VPACKSSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 6B /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpacksswb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpacksswb<T, U, V>, 

VPACKSSWB instruction

Instruction	Opcode	CPUID
VPACKSSWB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 63 /r	AVX
VPACKSSWB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 63 /r	AVX2
VPACKSSWB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 63 /r	AVX512VL AVX512BW
VPACKSSWB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 63 /r	AVX512VL AVX512BW
VPACKSSWB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 63 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpackusdw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpackusdw<T, U, V>, 

VPACKUSDW instruction

Instruction	Opcode	CPUID
VPACKUSDW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 2B /r	AVX
VPACKUSDW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 2B /r	AVX2
VPACKUSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 2B /r	AVX512VL AVX512BW
VPACKUSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 2B /r	AVX512VL AVX512BW
VPACKUSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 2B /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpackuswb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpackuswb<T, U, V>, 

VPACKUSWB instruction

Instruction	Opcode	CPUID
VPACKUSWB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 67 /r	AVX
VPACKUSWB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 67 /r	AVX2
VPACKUSWB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 67 /r	AVX512VL AVX512BW
VPACKUSWB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 67 /r	AVX512VL AVX512BW
VPACKUSWB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 67 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpaddb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpaddb<T, U, V>, 

VPADDB instruction

Instruction	Opcode	CPUID
VPADDB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG FC /r	AVX
VPADDB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG FC /r	AVX2
VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG FC /r	AVX512VL AVX512BW
VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG FC /r	AVX512VL AVX512BW
VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG FC /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpaddd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpaddd<T, U, V>, 

VPADDD instruction

Instruction	Opcode	CPUID
VPADDD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG FE /r	AVX
VPADDD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG FE /r	AVX2
VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 FE /r	AVX512VL AVX512F
VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 FE /r	AVX512VL AVX512F
VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 FE /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpaddq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpaddq<T, U, V>, 

VPADDQ instruction

Instruction	Opcode	CPUID
VPADDQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG D4 /r	AVX
VPADDQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG D4 /r	AVX2
VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 D4 /r	AVX512VL AVX512F
VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 D4 /r	AVX512VL AVX512F
VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 D4 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpaddsb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpaddsb<T, U, V>, 

VPADDSB instruction

Instruction	Opcode	CPUID
VPADDSB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG EC /r	AVX
VPADDSB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG EC /r	AVX2
VPADDSB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG EC /r	AVX512VL AVX512BW
VPADDSB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG EC /r	AVX512VL AVX512BW
VPADDSB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG EC /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpaddsw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpaddsw<T, U, V>, 

VPADDSW instruction

Instruction	Opcode	CPUID
VPADDSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG ED /r	AVX
VPADDSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG ED /r	AVX2
VPADDSW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG ED /r	AVX512VL AVX512BW
VPADDSW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG ED /r	AVX512VL AVX512BW
VPADDSW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG ED /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpaddusb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpaddusb<T, U, V>, 

VPADDUSB instruction

Instruction	Opcode	CPUID
VPADDUSB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG DC /r	AVX
VPADDUSB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG DC /r	AVX2
VPADDUSB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG DC /r	AVX512VL AVX512BW
VPADDUSB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG DC /r	AVX512VL AVX512BW
VPADDUSB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG DC /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpaddusw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpaddusw<T, U, V>, 

VPADDUSW instruction

Instruction	Opcode	CPUID
VPADDUSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG DD /r	AVX
VPADDUSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG DD /r	AVX2
VPADDUSW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG DD /r	AVX512VL AVX512BW
VPADDUSW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG DD /r	AVX512VL AVX512BW
VPADDUSW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG DD /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpaddw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpaddw<T, U, V>, 

VPADDW instruction

Instruction	Opcode	CPUID
VPADDW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG FD /r	AVX
VPADDW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG FD /r	AVX2
VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG FD /r	AVX512VL AVX512BW
VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG FD /r	AVX512VL AVX512BW
VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG FD /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpalignr<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpalignr<T, U, V, W>, 

VPALIGNR instruction

Instruction	Opcode	CPUID
VPALIGNR xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 0F /r ib	AVX
VPALIGNR ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 0F /r ib	AVX2
VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.WIG 0F /r ib	AVX512VL AVX512BW
VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.WIG 0F /r ib	AVX512VL AVX512BW
VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.WIG 0F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpand<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpand<T, U, V>, 

VPAND instruction

Instruction	Opcode	CPUID
VPAND xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG DB /r	AVX
VPAND ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG DB /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpandd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpandd<T, U, V>, 

VPANDD instruction

Instruction	Opcode	CPUID
VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 DB /r	AVX512VL AVX512F
VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 DB /r	AVX512VL AVX512F
VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 DB /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpandn<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpandn<T, U, V>, 

VPANDN instruction

Instruction	Opcode	CPUID
VPANDN xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG DF /r	AVX
VPANDN ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG DF /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpandnd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpandnd<T, U, V>, 

VPANDND instruction

Instruction	Opcode	CPUID
VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 DF /r	AVX512VL AVX512F
VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 DF /r	AVX512VL AVX512F
VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 DF /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpandnq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpandnq<T, U, V>, 

VPANDNQ instruction

Instruction	Opcode	CPUID
VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 DF /r	AVX512VL AVX512F
VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 DF /r	AVX512VL AVX512F
VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 DF /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpandq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpandq<T, U, V>, 

VPANDQ instruction

Instruction	Opcode	CPUID
VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 DB /r	AVX512VL AVX512F
VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 DB /r	AVX512VL AVX512F
VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 DB /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpavgb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpavgb<T, U, V>, 

VPAVGB instruction

Instruction	Opcode	CPUID
VPAVGB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG E0 /r	AVX
VPAVGB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG E0 /r	AVX2
VPAVGB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG E0 /r	AVX512VL AVX512BW
VPAVGB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG E0 /r	AVX512VL AVX512BW
VPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG E0 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpavgw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpavgw<T, U, V>, 

VPAVGW instruction

Instruction	Opcode	CPUID
VPAVGW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG E3 /r	AVX
VPAVGW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG E3 /r	AVX2
VPAVGW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG E3 /r	AVX512VL AVX512BW
VPAVGW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG E3 /r	AVX512VL AVX512BW
VPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG E3 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpblendd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpblendd<T, U, V, W>, 

VPBLENDD instruction

Instruction	Opcode	CPUID
VPBLENDD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.W0 02 /r ib	AVX2
VPBLENDD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.W0 02 /r ib	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpblendmb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpblendmb<T, U, V>, 

VPBLENDMB instruction

Instruction	Opcode	CPUID
VPBLENDMB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W0 66 /r	AVX512VL AVX512BW
VPBLENDMB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W0 66 /r	AVX512VL AVX512BW
VPBLENDMB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W0 66 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpblendmd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpblendmd<T, U, V>, 

VPBLENDMD instruction

Instruction	Opcode	CPUID
VPBLENDMD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 64 /r	AVX512VL AVX512F
VPBLENDMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 64 /r	AVX512VL AVX512F
VPBLENDMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 64 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpblendmq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpblendmq<T, U, V>, 

VPBLENDMQ instruction

Instruction	Opcode	CPUID
VPBLENDMQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 64 /r	AVX512VL AVX512F
VPBLENDMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 64 /r	AVX512VL AVX512F
VPBLENDMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 64 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpblendmw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpblendmw<T, U, V>, 

VPBLENDMW instruction

Instruction	Opcode	CPUID
VPBLENDMW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 66 /r	AVX512VL AVX512BW
VPBLENDMW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 66 /r	AVX512VL AVX512BW
VPBLENDMW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 66 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpblendvb<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpblendvb<T, U, V, W>, 

VPBLENDVB instruction

Instruction	Opcode	CPUID
VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4	VEX.128.66.0F3A.W0 4C /r /is4	AVX
VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4	VEX.256.66.0F3A.W0 4C /r /is4	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpblendw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpblendw<T, U, V, W>, 

VPBLENDW instruction

Instruction	Opcode	CPUID
VPBLENDW xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 0E /r ib	AVX
VPBLENDW ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 0E /r ib	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpbroadcastb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpbroadcastb<T, U>, 

VPBROADCASTB instruction

Instruction	Opcode	CPUID
VPBROADCASTB xmm1, xmm2/m8	VEX.128.66.0F38.W0 78 /r	AVX2
VPBROADCASTB ymm1, xmm2/m8	VEX.256.66.0F38.W0 78 /r	AVX2
VPBROADCASTB xmm1 {k1}{z}, xmm2/m8	EVEX.128.66.0F38.W0 78 /r	AVX512VL AVX512BW
VPBROADCASTB ymm1 {k1}{z}, xmm2/m8	EVEX.256.66.0F38.W0 78 /r	AVX512VL AVX512BW
VPBROADCASTB zmm1 {k1}{z}, xmm2/m8	EVEX.512.66.0F38.W0 78 /r	AVX512BW
VPBROADCASTB xmm1 {k1}{z}, r32	EVEX.128.66.0F38.W0 7A /r	AVX512VL AVX512BW
VPBROADCASTB ymm1 {k1}{z}, r32	EVEX.256.66.0F38.W0 7A /r	AVX512VL AVX512BW
VPBROADCASTB zmm1 {k1}{z}, r32	EVEX.512.66.0F38.W0 7A /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpbroadcastd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpbroadcastd<T, U>, 

VPBROADCASTD instruction

Instruction	Opcode	CPUID
VPBROADCASTD xmm1, xmm2/m32	VEX.128.66.0F38.W0 58 /r	AVX2
VPBROADCASTD ymm1, xmm2/m32	VEX.256.66.0F38.W0 58 /r	AVX2
VPBROADCASTD xmm1 {k1}{z}, xmm2/m32	EVEX.128.66.0F38.W0 58 /r	AVX512VL AVX512F
VPBROADCASTD ymm1 {k1}{z}, xmm2/m32	EVEX.256.66.0F38.W0 58 /r	AVX512VL AVX512F
VPBROADCASTD zmm1 {k1}{z}, xmm2/m32	EVEX.512.66.0F38.W0 58 /r	AVX512F
VPBROADCASTD xmm1 {k1}{z}, r32	EVEX.128.66.0F38.W0 7C /r	AVX512VL AVX512F
VPBROADCASTD ymm1 {k1}{z}, r32	EVEX.256.66.0F38.W0 7C /r	AVX512VL AVX512F
VPBROADCASTD zmm1 {k1}{z}, r32	EVEX.512.66.0F38.W0 7C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpbroadcastmb2q<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpbroadcastmb2q<T, U>, 

VPBROADCASTMB2Q instruction

Instruction	Opcode	CPUID
VPBROADCASTMB2Q xmm1, k1	EVEX.128.F3.0F38.W1 2A /r	AVX512VL AVX512CD
VPBROADCASTMB2Q ymm1, k1	EVEX.256.F3.0F38.W1 2A /r	AVX512VL AVX512CD
VPBROADCASTMB2Q zmm1, k1	EVEX.512.F3.0F38.W1 2A /r	AVX512CD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpbroadcastmw2d<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpbroadcastmw2d<T, U>, 

VPBROADCASTMW2D instruction

Instruction	Opcode	CPUID
VPBROADCASTMW2D xmm1, k1	EVEX.128.F3.0F38.W0 3A /r	AVX512VL AVX512CD
VPBROADCASTMW2D ymm1, k1	EVEX.256.F3.0F38.W0 3A /r	AVX512VL AVX512CD
VPBROADCASTMW2D zmm1, k1	EVEX.512.F3.0F38.W0 3A /r	AVX512CD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpbroadcastq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpbroadcastq<T, U>, 

VPBROADCASTQ instruction

Instruction	Opcode	CPUID
VPBROADCASTQ xmm1, xmm2/m64	VEX.128.66.0F38.W0 59 /r	AVX2
VPBROADCASTQ ymm1, xmm2/m64	VEX.256.66.0F38.W0 59 /r	AVX2
VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64	EVEX.128.66.0F38.W1 59 /r	AVX512VL AVX512F
VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64	EVEX.256.66.0F38.W1 59 /r	AVX512VL AVX512F
VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64	EVEX.512.66.0F38.W1 59 /r	AVX512F
VPBROADCASTQ xmm1 {k1}{z}, r64	EVEX.128.66.0F38.W1 7C /r	AVX512VL AVX512F
VPBROADCASTQ ymm1 {k1}{z}, r64	EVEX.256.66.0F38.W1 7C /r	AVX512VL AVX512F
VPBROADCASTQ zmm1 {k1}{z}, r64	EVEX.512.66.0F38.W1 7C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpbroadcastw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpbroadcastw<T, U>, 

VPBROADCASTW instruction

Instruction	Opcode	CPUID
VPBROADCASTW xmm1, xmm2/m16	VEX.128.66.0F38.W0 79 /r	AVX2
VPBROADCASTW ymm1, xmm2/m16	VEX.256.66.0F38.W0 79 /r	AVX2
VPBROADCASTW xmm1 {k1}{z}, xmm2/m16	EVEX.128.66.0F38.W0 79 /r	AVX512VL AVX512BW
VPBROADCASTW ymm1 {k1}{z}, xmm2/m16	EVEX.256.66.0F38.W0 79 /r	AVX512VL AVX512BW
VPBROADCASTW zmm1 {k1}{z}, xmm2/m16	EVEX.512.66.0F38.W0 79 /r	AVX512BW
VPBROADCASTW xmm1 {k1}{z}, r32	EVEX.128.66.0F38.W0 7B /r	AVX512VL AVX512BW
VPBROADCASTW ymm1 {k1}{z}, r32	EVEX.256.66.0F38.W0 7B /r	AVX512VL AVX512BW
VPBROADCASTW zmm1 {k1}{z}, r32	EVEX.512.66.0F38.W0 7B /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpclmulhqhqdq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpclmulhqhqdq<T, U, V>, 

VPCLMULHQHQDQ instruction

Instruction	Opcode	CPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 44 /r ib	PCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 44 /r ib	VPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.WIG 44 /r ib	AVX512F VPCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpclmulhqlqdq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpclmulhqlqdq<T, U, V>, 

VPCLMULHQLQDQ instruction

Instruction	Opcode	CPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 44 /r ib	PCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 44 /r ib	VPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.WIG 44 /r ib	AVX512F VPCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpclmullqhqdq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpclmullqhqdq<T, U, V>, 

VPCLMULLQHQDQ instruction

Instruction	Opcode	CPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 44 /r ib	PCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 44 /r ib	VPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.WIG 44 /r ib	AVX512F VPCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpclmullqlqdq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpclmullqlqdq<T, U, V>, 

VPCLMULLQLQDQ instruction

Instruction	Opcode	CPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 44 /r ib	PCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 44 /r ib	VPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.WIG 44 /r ib	AVX512F VPCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpclmulqdq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpclmulqdq<T, U, V, W>, 

VPCLMULQDQ instruction

Instruction	Opcode	CPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.WIG 44 /r ib	PCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.WIG 44 /r ib	VPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.WIG 44 /r ib	AVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.WIG 44 /r ib	AVX512F VPCLMULQDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcmov<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmov<T, U, V, W>, 

VPCMOV instruction

Instruction	Opcode	CPUID
VPCMOV xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 A2 /r /is4	XOP
VPCMOV ymm1, ymm2, ymm3/m256, ymm4	XOP.256.X8.W0 A2 /r /is4	XOP
VPCMOV xmm1, xmm2, xmm3, xmm4/m128	XOP.128.X8.W1 A2 /r /is4	XOP
VPCMOV ymm1, ymm2, ymm3, ymm4/m256	XOP.256.X8.W1 A2 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcmpb<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpb<T, U, V, W>, 

VPCMPB instruction

Instruction	Opcode	CPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcmpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpd<T, U, V, W>, 

VPCMPD instruction

Instruction	Opcode	CPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcmpeqb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpeqb<T, U, V>, 

VPCMPEQB instruction

Instruction	Opcode	CPUID
VPCMPEQB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 74 /r	AVX
VPCMPEQB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 74 /r	AVX2
VPCMPEQB k1 {k2}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 74 /r	AVX512VL AVX512BW
VPCMPEQB k1 {k2}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 74 /r	AVX512VL AVX512BW
VPCMPEQB k1 {k2}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 74 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpeqd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpeqd<T, U, V>, 

VPCMPEQD instruction

Instruction	Opcode	CPUID
VPCMPEQD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 76 /r	AVX
VPCMPEQD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 76 /r	AVX2
VPCMPEQD k1 {k2}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 76 /r	AVX512VL AVX512F
VPCMPEQD k1 {k2}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 76 /r	AVX512VL AVX512F
VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 76 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpeqq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpeqq<T, U, V>, 

VPCMPEQQ instruction

Instruction	Opcode	CPUID
VPCMPEQQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 29 /r	AVX
VPCMPEQQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 29 /r	AVX2
VPCMPEQQ k1 {k2}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 29 /r	AVX512VL AVX512F
VPCMPEQQ k1 {k2}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 29 /r	AVX512VL AVX512F
VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 29 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpequb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpequb<T, U, V>, 

VPCMPEQUB instruction

Instruction	Opcode	CPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpequd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpequd<T, U, V>, 

VPCMPEQUD instruction

Instruction	Opcode	CPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpequq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpequq<T, U, V>, 

VPCMPEQUQ instruction

Instruction	Opcode	CPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpequw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpequw<T, U, V>, 

VPCMPEQUW instruction

Instruction	Opcode	CPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpeqw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpeqw<T, U, V>, 

VPCMPEQW instruction

Instruction	Opcode	CPUID
VPCMPEQW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 75 /r	AVX
VPCMPEQW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 75 /r	AVX2
VPCMPEQW k1 {k2}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 75 /r	AVX512VL AVX512BW
VPCMPEQW k1 {k2}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 75 /r	AVX512VL AVX512BW
VPCMPEQW k1 {k2}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 75 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpestri<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpestri<T, U, V>, 

VPCMPESTRI instruction

Instruction	Opcode	CPUID
VPCMPESTRI xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.W0 61 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpestri64<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpestri64<T, U, V>, 

VPCMPESTRI64 instruction

Instruction	Opcode	CPUID
VPCMPESTRI64 xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.W1 61 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpestrm<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpestrm<T, U, V>, 

VPCMPESTRM instruction

Instruction	Opcode	CPUID
VPCMPESTRM xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.W0 60 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpestrm64<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpestrm64<T, U, V>, 

VPCMPESTRM64 instruction

Instruction	Opcode	CPUID
VPCMPESTRM64 xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.W1 60 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpfalseb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpfalseb<T, U, V>, 

VPCMPFALSEB instruction

Instruction	Opcode	CPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpfalsed<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpfalsed<T, U, V>, 

VPCMPFALSED instruction

Instruction	Opcode	CPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpfalseq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpfalseq<T, U, V>, 

VPCMPFALSEQ instruction

Instruction	Opcode	CPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpfalseub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpfalseub<T, U, V>, 

VPCMPFALSEUB instruction

Instruction	Opcode	CPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpfalseud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpfalseud<T, U, V>, 

VPCMPFALSEUD instruction

Instruction	Opcode	CPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpfalseuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpfalseuq<T, U, V>, 

VPCMPFALSEUQ instruction

Instruction	Opcode	CPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpfalseuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpfalseuw<T, U, V>, 

VPCMPFALSEUW instruction

Instruction	Opcode	CPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpfalsew<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpfalsew<T, U, V>, 

VPCMPFALSEW instruction

Instruction	Opcode	CPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpgtb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpgtb<T, U, V>, 

VPCMPGTB instruction

Instruction	Opcode	CPUID
VPCMPGTB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 64 /r	AVX
VPCMPGTB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 64 /r	AVX2
VPCMPGTB k1 {k2}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 64 /r	AVX512VL AVX512BW
VPCMPGTB k1 {k2}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 64 /r	AVX512VL AVX512BW
VPCMPGTB k1 {k2}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 64 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpgtd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpgtd<T, U, V>, 

VPCMPGTD instruction

Instruction	Opcode	CPUID
VPCMPGTD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 66 /r	AVX
VPCMPGTD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 66 /r	AVX2
VPCMPGTD k1 {k2}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 66 /r	AVX512VL AVX512F
VPCMPGTD k1 {k2}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 66 /r	AVX512VL AVX512F
VPCMPGTD k1 {k2}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 66 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpgtq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpgtq<T, U, V>, 

VPCMPGTQ instruction

Instruction	Opcode	CPUID
VPCMPGTQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 37 /r	AVX
VPCMPGTQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 37 /r	AVX2
VPCMPGTQ k1 {k2}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 37 /r	AVX512VL AVX512F
VPCMPGTQ k1 {k2}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 37 /r	AVX512VL AVX512F
VPCMPGTQ k1 {k2}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 37 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpgtw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpgtw<T, U, V>, 

VPCMPGTW instruction

Instruction	Opcode	CPUID
VPCMPGTW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 65 /r	AVX
VPCMPGTW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 65 /r	AVX2
VPCMPGTW k1 {k2}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 65 /r	AVX512VL AVX512BW
VPCMPGTW k1 {k2}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 65 /r	AVX512VL AVX512BW
VPCMPGTW k1 {k2}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 65 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpistri<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpistri<T, U, V>, 

VPCMPISTRI instruction

Instruction	Opcode	CPUID
VPCMPISTRI xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.WIG 63 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpistrm<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpistrm<T, U, V>, 

VPCMPISTRM instruction

Instruction	Opcode	CPUID
VPCMPISTRM xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.WIG 62 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpleb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpleb<T, U, V>, 

VPCMPLEB instruction

Instruction	Opcode	CPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpled<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpled<T, U, V>, 

VPCMPLED instruction

Instruction	Opcode	CPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpleq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpleq<T, U, V>, 

VPCMPLEQ instruction

Instruction	Opcode	CPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpleub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpleub<T, U, V>, 

VPCMPLEUB instruction

Instruction	Opcode	CPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpleud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpleud<T, U, V>, 

VPCMPLEUD instruction

Instruction	Opcode	CPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpleuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpleuq<T, U, V>, 

VPCMPLEUQ instruction

Instruction	Opcode	CPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpleuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpleuw<T, U, V>, 

VPCMPLEUW instruction

Instruction	Opcode	CPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmplew<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmplew<T, U, V>, 

VPCMPLEW instruction

Instruction	Opcode	CPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpltb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpltb<T, U, V>, 

VPCMPLTB instruction

Instruction	Opcode	CPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpltd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpltd<T, U, V>, 

VPCMPLTD instruction

Instruction	Opcode	CPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpltq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpltq<T, U, V>, 

VPCMPLTQ instruction

Instruction	Opcode	CPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpltub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpltub<T, U, V>, 

VPCMPLTUB instruction

Instruction	Opcode	CPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpltud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpltud<T, U, V>, 

VPCMPLTUD instruction

Instruction	Opcode	CPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpltuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpltuq<T, U, V>, 

VPCMPLTUQ instruction

Instruction	Opcode	CPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpltuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpltuw<T, U, V>, 

VPCMPLTUW instruction

Instruction	Opcode	CPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpltw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpltw<T, U, V>, 

VPCMPLTW instruction

Instruction	Opcode	CPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpneqb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpneqb<T, U, V>, 

VPCMPNEQB instruction

Instruction	Opcode	CPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpneqd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpneqd<T, U, V>, 

VPCMPNEQD instruction

Instruction	Opcode	CPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpneqq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpneqq<T, U, V>, 

VPCMPNEQQ instruction

Instruction	Opcode	CPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnequb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnequb<T, U, V>, 

VPCMPNEQUB instruction

Instruction	Opcode	CPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnequd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnequd<T, U, V>, 

VPCMPNEQUD instruction

Instruction	Opcode	CPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnequq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnequq<T, U, V>, 

VPCMPNEQUQ instruction

Instruction	Opcode	CPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnequw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnequw<T, U, V>, 

VPCMPNEQUW instruction

Instruction	Opcode	CPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpneqw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpneqw<T, U, V>, 

VPCMPNEQW instruction

Instruction	Opcode	CPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnleb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnleb<T, U, V>, 

VPCMPNLEB instruction

Instruction	Opcode	CPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnled<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnled<T, U, V>, 

VPCMPNLED instruction

Instruction	Opcode	CPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnleq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnleq<T, U, V>, 

VPCMPNLEQ instruction

Instruction	Opcode	CPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnleub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnleub<T, U, V>, 

VPCMPNLEUB instruction

Instruction	Opcode	CPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnleud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnleud<T, U, V>, 

VPCMPNLEUD instruction

Instruction	Opcode	CPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnleuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnleuq<T, U, V>, 

VPCMPNLEUQ instruction

Instruction	Opcode	CPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnleuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnleuw<T, U, V>, 

VPCMPNLEUW instruction

Instruction	Opcode	CPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnlew<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnlew<T, U, V>, 

VPCMPNLEW instruction

Instruction	Opcode	CPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnltb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnltb<T, U, V>, 

VPCMPNLTB instruction

Instruction	Opcode	CPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnltd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnltd<T, U, V>, 

VPCMPNLTD instruction

Instruction	Opcode	CPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnltq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnltq<T, U, V>, 

VPCMPNLTQ instruction

Instruction	Opcode	CPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnltub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnltub<T, U, V>, 

VPCMPNLTUB instruction

Instruction	Opcode	CPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnltud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnltud<T, U, V>, 

VPCMPNLTUD instruction

Instruction	Opcode	CPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnltuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnltuq<T, U, V>, 

VPCMPNLTUQ instruction

Instruction	Opcode	CPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnltuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnltuw<T, U, V>, 

VPCMPNLTUW instruction

Instruction	Opcode	CPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpnltw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpnltw<T, U, V>, 

VPCMPNLTW instruction

Instruction	Opcode	CPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpq<T, U, V, W>, 

VPCMPQ instruction

Instruction	Opcode	CPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcmptrueb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmptrueb<T, U, V>, 

VPCMPTRUEB instruction

Instruction	Opcode	CPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3F /r ib	AVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmptrued<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmptrued<T, U, V>, 

VPCMPTRUED instruction

Instruction	Opcode	CPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1F /r ib	AVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmptrueq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmptrueq<T, U, V>, 

VPCMPTRUEQ instruction

Instruction	Opcode	CPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1F /r ib	AVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1F /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmptrueub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmptrueub<T, U, V>, 

VPCMPTRUEUB instruction

Instruction	Opcode	CPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmptrueud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmptrueud<T, U, V>, 

VPCMPTRUEUD instruction

Instruction	Opcode	CPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmptrueuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmptrueuq<T, U, V>, 

VPCMPTRUEUQ instruction

Instruction	Opcode	CPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmptrueuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmptrueuw<T, U, V>, 

VPCMPTRUEUW instruction

Instruction	Opcode	CPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmptruew<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmptruew<T, U, V>, 

VPCMPTRUEW instruction

Instruction	Opcode	CPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcmpub<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpub<T, U, V, W>, 

VPCMPUB instruction

Instruction	Opcode	CPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W0 3E /r ib	AVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W0 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcmpud<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpud<T, U, V, W>, 

VPCMPUD instruction

Instruction	Opcode	CPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 1E /r ib	AVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcmpuq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpuq<T, U, V, W>, 

VPCMPUQ instruction

Instruction	Opcode	CPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 1E /r ib	AVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 1E /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcmpuw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpuw<T, U, V, W>, 

VPCMPUW instruction

Instruction	Opcode	CPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3E /r ib	AVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3E /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcmpw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcmpw<T, U, V, W>, 

VPCMPW instruction

Instruction	Opcode	CPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 3F /r ib	AVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 3F /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcomb<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomb<T, U, V, W>, 

VPCOMB instruction

Instruction	Opcode	CPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcomd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomd<T, U, V, W>, 

VPCOMD instruction

Instruction	Opcode	CPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcomeqb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomeqb<T, U, V>, 

VPCOMEQB instruction

Instruction	Opcode	CPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomeqd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomeqd<T, U, V>, 

VPCOMEQD instruction

Instruction	Opcode	CPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomeqq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomeqq<T, U, V>, 

VPCOMEQQ instruction

Instruction	Opcode	CPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomequb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomequb<T, U, V>, 

VPCOMEQUB instruction

Instruction	Opcode	CPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomequd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomequd<T, U, V>, 

VPCOMEQUD instruction

Instruction	Opcode	CPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomequq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomequq<T, U, V>, 

VPCOMEQUQ instruction

Instruction	Opcode	CPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomequw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomequw<T, U, V>, 

VPCOMEQUW instruction

Instruction	Opcode	CPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 ED /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomeqw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomeqw<T, U, V>, 

VPCOMEQW instruction

Instruction	Opcode	CPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CD /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomfalseb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomfalseb<T, U, V>, 

VPCOMFALSEB instruction

Instruction	Opcode	CPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomfalsed<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomfalsed<T, U, V>, 

VPCOMFALSED instruction

Instruction	Opcode	CPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomfalseq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomfalseq<T, U, V>, 

VPCOMFALSEQ instruction

Instruction	Opcode	CPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomfalseub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomfalseub<T, U, V>, 

VPCOMFALSEUB instruction

Instruction	Opcode	CPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomfalseud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomfalseud<T, U, V>, 

VPCOMFALSEUD instruction

Instruction	Opcode	CPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomfalseuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomfalseuq<T, U, V>, 

VPCOMFALSEUQ instruction

Instruction	Opcode	CPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomfalseuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomfalseuw<T, U, V>, 

VPCOMFALSEUW instruction

Instruction	Opcode	CPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 ED /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomfalsew<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomfalsew<T, U, V>, 

VPCOMFALSEW instruction

Instruction	Opcode	CPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CD /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgeb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgeb<T, U, V>, 

VPCOMGEB instruction

Instruction	Opcode	CPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomged<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomged<T, U, V>, 

VPCOMGED instruction

Instruction	Opcode	CPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgeq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgeq<T, U, V>, 

VPCOMGEQ instruction

Instruction	Opcode	CPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgeub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgeub<T, U, V>, 

VPCOMGEUB instruction

Instruction	Opcode	CPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgeud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgeud<T, U, V>, 

VPCOMGEUD instruction

Instruction	Opcode	CPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgeuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgeuq<T, U, V>, 

VPCOMGEUQ instruction

Instruction	Opcode	CPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgeuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgeuw<T, U, V>, 

VPCOMGEUW instruction

Instruction	Opcode	CPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 ED /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgew<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgew<T, U, V>, 

VPCOMGEW instruction

Instruction	Opcode	CPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CD /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgtb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgtb<T, U, V>, 

VPCOMGTB instruction

Instruction	Opcode	CPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgtd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgtd<T, U, V>, 

VPCOMGTD instruction

Instruction	Opcode	CPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgtq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgtq<T, U, V>, 

VPCOMGTQ instruction

Instruction	Opcode	CPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgtub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgtub<T, U, V>, 

VPCOMGTUB instruction

Instruction	Opcode	CPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgtud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgtud<T, U, V>, 

VPCOMGTUD instruction

Instruction	Opcode	CPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgtuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgtuq<T, U, V>, 

VPCOMGTUQ instruction

Instruction	Opcode	CPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgtuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgtuw<T, U, V>, 

VPCOMGTUW instruction

Instruction	Opcode	CPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 ED /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomgtw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomgtw<T, U, V>, 

VPCOMGTW instruction

Instruction	Opcode	CPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CD /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomleb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomleb<T, U, V>, 

VPCOMLEB instruction

Instruction	Opcode	CPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomled<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomled<T, U, V>, 

VPCOMLED instruction

Instruction	Opcode	CPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomleq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomleq<T, U, V>, 

VPCOMLEQ instruction

Instruction	Opcode	CPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomleub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomleub<T, U, V>, 

VPCOMLEUB instruction

Instruction	Opcode	CPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomleud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomleud<T, U, V>, 

VPCOMLEUD instruction

Instruction	Opcode	CPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomleuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomleuq<T, U, V>, 

VPCOMLEUQ instruction

Instruction	Opcode	CPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomleuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomleuw<T, U, V>, 

VPCOMLEUW instruction

Instruction	Opcode	CPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 ED /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomlew<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomlew<T, U, V>, 

VPCOMLEW instruction

Instruction	Opcode	CPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CD /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomltb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomltb<T, U, V>, 

VPCOMLTB instruction

Instruction	Opcode	CPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomltd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomltd<T, U, V>, 

VPCOMLTD instruction

Instruction	Opcode	CPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomltq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomltq<T, U, V>, 

VPCOMLTQ instruction

Instruction	Opcode	CPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomltub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomltub<T, U, V>, 

VPCOMLTUB instruction

Instruction	Opcode	CPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomltud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomltud<T, U, V>, 

VPCOMLTUD instruction

Instruction	Opcode	CPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomltuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomltuq<T, U, V>, 

VPCOMLTUQ instruction

Instruction	Opcode	CPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomltuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomltuw<T, U, V>, 

VPCOMLTUW instruction

Instruction	Opcode	CPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 ED /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomltw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomltw<T, U, V>, 

VPCOMLTW instruction

Instruction	Opcode	CPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CD /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomneqb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomneqb<T, U, V>, 

VPCOMNEQB instruction

Instruction	Opcode	CPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomneqd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomneqd<T, U, V>, 

VPCOMNEQD instruction

Instruction	Opcode	CPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomneqq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomneqq<T, U, V>, 

VPCOMNEQQ instruction

Instruction	Opcode	CPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomnequb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomnequb<T, U, V>, 

VPCOMNEQUB instruction

Instruction	Opcode	CPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomnequd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomnequd<T, U, V>, 

VPCOMNEQUD instruction

Instruction	Opcode	CPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomnequq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomnequq<T, U, V>, 

VPCOMNEQUQ instruction

Instruction	Opcode	CPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomnequw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomnequw<T, U, V>, 

VPCOMNEQUW instruction

Instruction	Opcode	CPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 ED /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomneqw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomneqw<T, U, V>, 

VPCOMNEQW instruction

Instruction	Opcode	CPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CD /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcompressb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpcompressb<T, U>, 

VPCOMPRESSB instruction

Instruction	Opcode	CPUID
VPCOMPRESSB xmm1/m128 {k1}{z}, xmm2	EVEX.128.66.0F38.W0 63 /r	AVX512VL AVX512_VBMI2
VPCOMPRESSB ymm1/m256 {k1}{z}, ymm2	EVEX.256.66.0F38.W0 63 /r	AVX512VL AVX512_VBMI2
VPCOMPRESSB zmm1/m512 {k1}{z}, zmm2	EVEX.512.66.0F38.W0 63 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpcompressd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpcompressd<T, U>, 

VPCOMPRESSD instruction

Instruction	Opcode	CPUID
VPCOMPRESSD xmm1/m128 {k1}{z}, xmm2	EVEX.128.66.0F38.W0 8B /r	AVX512VL AVX512F
VPCOMPRESSD ymm1/m256 {k1}{z}, ymm2	EVEX.256.66.0F38.W0 8B /r	AVX512VL AVX512F
VPCOMPRESSD zmm1/m512 {k1}{z}, zmm2	EVEX.512.66.0F38.W0 8B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpcompressq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpcompressq<T, U>, 

VPCOMPRESSQ instruction

Instruction	Opcode	CPUID
VPCOMPRESSQ xmm1/m128 {k1}{z}, xmm2	EVEX.128.66.0F38.W1 8B /r	AVX512VL AVX512F
VPCOMPRESSQ ymm1/m256 {k1}{z}, ymm2	EVEX.256.66.0F38.W1 8B /r	AVX512VL AVX512F
VPCOMPRESSQ zmm1/m512 {k1}{z}, zmm2	EVEX.512.66.0F38.W1 8B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpcompressw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpcompressw<T, U>, 

VPCOMPRESSW instruction

Instruction	Opcode	CPUID
VPCOMPRESSW xmm1/m128 {k1}{z}, xmm2	EVEX.128.66.0F38.W1 63 /r	AVX512VL AVX512_VBMI2
VPCOMPRESSW ymm1/m256 {k1}{z}, ymm2	EVEX.256.66.0F38.W1 63 /r	AVX512VL AVX512_VBMI2
VPCOMPRESSW zmm1/m512 {k1}{z}, zmm2	EVEX.512.66.0F38.W1 63 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpcomq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomq<T, U, V, W>, 

VPCOMQ instruction

Instruction	Opcode	CPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcomtrueb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomtrueb<T, U, V>, 

VPCOMTRUEB instruction

Instruction	Opcode	CPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomtrued<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomtrued<T, U, V>, 

VPCOMTRUED instruction

Instruction	Opcode	CPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomtrueq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomtrueq<T, U, V>, 

VPCOMTRUEQ instruction

Instruction	Opcode	CPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomtrueub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomtrueub<T, U, V>, 

VPCOMTRUEUB instruction

Instruction	Opcode	CPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomtrueud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomtrueud<T, U, V>, 

VPCOMTRUEUD instruction

Instruction	Opcode	CPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomtrueuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomtrueuq<T, U, V>, 

VPCOMTRUEUQ instruction

Instruction	Opcode	CPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomtrueuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomtrueuw<T, U, V>, 

VPCOMTRUEUW instruction

Instruction	Opcode	CPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 ED /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomtruew<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomtruew<T, U, V>, 

VPCOMTRUEW instruction

Instruction	Opcode	CPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CD /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpcomub<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomub<T, U, V, W>, 

VPCOMUB instruction

Instruction	Opcode	CPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EC /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcomud<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomud<T, U, V, W>, 

VPCOMUD instruction

Instruction	Opcode	CPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EE /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcomuq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomuq<T, U, V, W>, 

VPCOMUQ instruction

Instruction	Opcode	CPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 EF /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcomuw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomuw<T, U, V, W>, 

VPCOMUW instruction

Instruction	Opcode	CPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 ED /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpcomw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpcomw<T, U, V, W>, 

VPCOMW instruction

Instruction	Opcode	CPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8	XOP.128.X8.W0 CD /r ib	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpconflictd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpconflictd<T, U>, 

VPCONFLICTD instruction

Instruction	Opcode	CPUID
VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.0F38.W0 C4 /r	AVX512VL AVX512CD
VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.0F38.W0 C4 /r	AVX512VL AVX512CD
VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst	EVEX.512.66.0F38.W0 C4 /r	AVX512CD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpconflictq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpconflictq<T, U>, 

VPCONFLICTQ instruction

Instruction	Opcode	CPUID
VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F38.W1 C4 /r	AVX512VL AVX512CD
VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F38.W1 C4 /r	AVX512VL AVX512CD
VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst	EVEX.512.66.0F38.W1 C4 /r	AVX512CD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpdpbusd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpdpbusd<T, U, V>, 

VPDPBUSD instruction

Instruction	Opcode	CPUID
VPDPBUSD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 50 /r	AVX-VNNI
VPDPBUSD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 50 /r	AVX-VNNI
VPDPBUSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 50 /r	AVX512VL AVX512_VNNI
VPDPBUSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 50 /r	AVX512VL AVX512_VNNI
VPDPBUSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 50 /r	AVX512_VNNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpdpbusds<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpdpbusds<T, U, V>, 

VPDPBUSDS instruction

Instruction	Opcode	CPUID
VPDPBUSDS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 51 /r	AVX-VNNI
VPDPBUSDS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 51 /r	AVX-VNNI
VPDPBUSDS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 51 /r	AVX512VL AVX512_VNNI
VPDPBUSDS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 51 /r	AVX512VL AVX512_VNNI
VPDPBUSDS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 51 /r	AVX512_VNNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpdpwssd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpdpwssd<T, U, V>, 

VPDPWSSD instruction

Instruction	Opcode	CPUID
VPDPWSSD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 52 /r	AVX-VNNI
VPDPWSSD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 52 /r	AVX-VNNI
VPDPWSSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 52 /r	AVX512VL AVX512_VNNI
VPDPWSSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 52 /r	AVX512VL AVX512_VNNI
VPDPWSSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 52 /r	AVX512_VNNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpdpwssds<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpdpwssds<T, U, V>, 

VPDPWSSDS instruction

Instruction	Opcode	CPUID
VPDPWSSDS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 53 /r	AVX-VNNI
VPDPWSSDS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 53 /r	AVX-VNNI
VPDPWSSDS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 53 /r	AVX512VL AVX512_VNNI
VPDPWSSDS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 53 /r	AVX512VL AVX512_VNNI
VPDPWSSDS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 53 /r	AVX512_VNNI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vperm2f128<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVperm2f128<T, U, V, W>, 

VPERM2F128 instruction

Instruction	Opcode	CPUID
VPERM2F128 ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.W0 06 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vperm2i128<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVperm2i128<T, U, V, W>, 

VPERM2I128 instruction

Instruction	Opcode	CPUID
VPERM2I128 ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F3A.W0 46 /r ib	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpermb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermb<T, U, V>, 

VPERMB instruction

Instruction	Opcode	CPUID
VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W0 8D /r	AVX512VL AVX512_VBMI
VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W0 8D /r	AVX512VL AVX512_VBMI
VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W0 8D /r	AVX512_VBMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermd<T, U, V>, 

VPERMD instruction

Instruction	Opcode	CPUID
VPERMD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 36 /r	AVX2
VPERMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 36 /r	AVX512VL AVX512F
VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 36 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermi2b<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermi2b<T, U, V>, 

VPERMI2B instruction

Instruction	Opcode	CPUID
VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W0 75 /r	AVX512VL AVX512_VBMI
VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W0 75 /r	AVX512VL AVX512_VBMI
VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W0 75 /r	AVX512_VBMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermi2d<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermi2d<T, U, V>, 

VPERMI2D instruction

Instruction	Opcode	CPUID
VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 76 /r	AVX512VL AVX512F
VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 76 /r	AVX512VL AVX512F
VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 76 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermi2pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermi2pd<T, U, V>, 

VPERMI2PD instruction

Instruction	Opcode	CPUID
VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 77 /r	AVX512VL AVX512F
VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 77 /r	AVX512VL AVX512F
VPERMI2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 77 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermi2ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermi2ps<T, U, V>, 

VPERMI2PS instruction

Instruction	Opcode	CPUID
VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 77 /r	AVX512VL AVX512F
VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 77 /r	AVX512VL AVX512F
VPERMI2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 77 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermi2q<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermi2q<T, U, V>, 

VPERMI2Q instruction

Instruction	Opcode	CPUID
VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 76 /r	AVX512VL AVX512F
VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 76 /r	AVX512VL AVX512F
VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 76 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermi2w<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermi2w<T, U, V>, 

VPERMI2W instruction

Instruction	Opcode	CPUID
VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 75 /r	AVX512VL AVX512BW
VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 75 /r	AVX512VL AVX512BW
VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 75 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermil2pd<T, U, V, W, X>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W,
    op4: X
) -> Result<(), IcedError> where
    Self: CodeAsmVpermil2pd<T, U, V, W, X>, 

VPERMIL2PD instruction

Instruction	Opcode	CPUID
VPERMIL2PD xmm1, xmm2, xmm3/m128, xmm4, imm4	VEX.128.66.0F3A.W0 49 /r /is5	XOP
VPERMIL2PD ymm1, ymm2, ymm3/m256, ymm4, imm4	VEX.256.66.0F3A.W0 49 /r /is5	XOP
VPERMIL2PD xmm1, xmm2, xmm3, xmm4/m128, imm4	VEX.128.66.0F3A.W1 49 /r /is5	XOP
VPERMIL2PD ymm1, ymm2, ymm3, ymm4/m256, imm4	VEX.256.66.0F3A.W1 49 /r /is5	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand
• op4: Fifth operand

pub fn vpermil2ps<T, U, V, W, X>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W,
    op4: X
) -> Result<(), IcedError> where
    Self: CodeAsmVpermil2ps<T, U, V, W, X>, 

VPERMIL2PS instruction

Instruction	Opcode	CPUID
VPERMIL2PS xmm1, xmm2, xmm3/m128, xmm4, imm4	VEX.128.66.0F3A.W0 48 /r /is5	XOP
VPERMIL2PS ymm1, ymm2, ymm3/m256, ymm4, imm4	VEX.256.66.0F3A.W0 48 /r /is5	XOP
VPERMIL2PS xmm1, xmm2, xmm3, xmm4/m128, imm4	VEX.128.66.0F3A.W1 48 /r /is5	XOP
VPERMIL2PS ymm1, ymm2, ymm3, ymm4/m256, imm4	VEX.256.66.0F3A.W1 48 /r /is5	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand
• op4: Fifth operand

pub fn vpermilpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermilpd<T, U, V>, 

VPERMILPD instruction

Instruction	Opcode	CPUID
VPERMILPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 0D /r	AVX
VPERMILPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 0D /r	AVX
VPERMILPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 0D /r	AVX512VL AVX512F
VPERMILPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 0D /r	AVX512VL AVX512F
VPERMILPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 0D /r	AVX512F
VPERMILPD xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.W0 05 /r ib	AVX
VPERMILPD ymm1, ymm2/m256, imm8	VEX.256.66.0F3A.W0 05 /r ib	AVX
VPERMILPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 05 /r ib	AVX512VL AVX512F
VPERMILPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 05 /r ib	AVX512VL AVX512F
VPERMILPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 05 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermilps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermilps<T, U, V>, 

VPERMILPS instruction

Instruction	Opcode	CPUID
VPERMILPS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 0C /r	AVX
VPERMILPS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 0C /r	AVX
VPERMILPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 0C /r	AVX512VL AVX512F
VPERMILPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 0C /r	AVX512VL AVX512F
VPERMILPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 0C /r	AVX512F
VPERMILPS xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.W0 04 /r ib	AVX
VPERMILPS ymm1, ymm2/m256, imm8	VEX.256.66.0F3A.W0 04 /r ib	AVX
VPERMILPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 04 /r ib	AVX512VL AVX512F
VPERMILPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 04 /r ib	AVX512VL AVX512F
VPERMILPS zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 04 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermpd<T, U, V>, 

VPERMPD instruction

Instruction	Opcode	CPUID
VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 16 /r	AVX512VL AVX512F
VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 16 /r	AVX512F
VPERMPD ymm1, ymm2/m256, imm8	VEX.256.66.0F3A.W1 01 /r ib	AVX2
VPERMPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 01 /r ib	AVX512VL AVX512F
VPERMPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 01 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermps<T, U, V>, 

VPERMPS instruction

Instruction	Opcode	CPUID
VPERMPS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 16 /r	AVX2
VPERMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 16 /r	AVX512VL AVX512F
VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 16 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermq<T, U, V>, 

VPERMQ instruction

Instruction	Opcode	CPUID
VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 36 /r	AVX512VL AVX512F
VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 36 /r	AVX512F
VPERMQ ymm1, ymm2/m256, imm8	VEX.256.66.0F3A.W1 00 /r ib	AVX2
VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 00 /r ib	AVX512VL AVX512F
VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 00 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermt2b<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermt2b<T, U, V>, 

VPERMT2B instruction

Instruction	Opcode	CPUID
VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W0 7D /r	AVX512VL AVX512_VBMI
VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W0 7D /r	AVX512VL AVX512_VBMI
VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W0 7D /r	AVX512_VBMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermt2d<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermt2d<T, U, V>, 

VPERMT2D instruction

Instruction	Opcode	CPUID
VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 7E /r	AVX512VL AVX512F
VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 7E /r	AVX512VL AVX512F
VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 7E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermt2pd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermt2pd<T, U, V>, 

VPERMT2PD instruction

Instruction	Opcode	CPUID
VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 7F /r	AVX512VL AVX512F
VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 7F /r	AVX512VL AVX512F
VPERMT2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 7F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermt2ps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermt2ps<T, U, V>, 

VPERMT2PS instruction

Instruction	Opcode	CPUID
VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 7F /r	AVX512VL AVX512F
VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 7F /r	AVX512VL AVX512F
VPERMT2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 7F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermt2q<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermt2q<T, U, V>, 

VPERMT2Q instruction

Instruction	Opcode	CPUID
VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 7E /r	AVX512VL AVX512F
VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 7E /r	AVX512VL AVX512F
VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 7E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermt2w<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermt2w<T, U, V>, 

VPERMT2W instruction

Instruction	Opcode	CPUID
VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 7D /r	AVX512VL AVX512BW
VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 7D /r	AVX512VL AVX512BW
VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 7D /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpermw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpermw<T, U, V>, 

VPERMW instruction

Instruction	Opcode	CPUID
VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 8D /r	AVX512VL AVX512BW
VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 8D /r	AVX512VL AVX512BW
VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 8D /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpexpandb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpexpandb<T, U>, 

VPEXPANDB instruction

Instruction	Opcode	CPUID
VPEXPANDB xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.W0 62 /r	AVX512VL AVX512_VBMI2
VPEXPANDB ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.W0 62 /r	AVX512VL AVX512_VBMI2
VPEXPANDB zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.W0 62 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpexpandd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpexpandd<T, U>, 

VPEXPANDD instruction

Instruction	Opcode	CPUID
VPEXPANDD xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.W0 89 /r	AVX512VL AVX512F
VPEXPANDD ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.W0 89 /r	AVX512VL AVX512F
VPEXPANDD zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.W0 89 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpexpandq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpexpandq<T, U>, 

VPEXPANDQ instruction

Instruction	Opcode	CPUID
VPEXPANDQ xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.W1 89 /r	AVX512VL AVX512F
VPEXPANDQ ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.W1 89 /r	AVX512VL AVX512F
VPEXPANDQ zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.W1 89 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpexpandw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpexpandw<T, U>, 

VPEXPANDW instruction

Instruction	Opcode	CPUID
VPEXPANDW xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.W1 62 /r	AVX512VL AVX512_VBMI2
VPEXPANDW ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.W1 62 /r	AVX512VL AVX512_VBMI2
VPEXPANDW zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.W1 62 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpextrb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpextrb<T, U, V>, 

VPEXTRB instruction

Instruction	Opcode	CPUID
VPEXTRB r32/m8, xmm2, imm8	VEX.128.66.0F3A.W0 14 /r ib	AVX
VPEXTRB r64/m8, xmm2, imm8	VEX.128.66.0F3A.W1 14 /r ib	AVX
VPEXTRB r32/m8, xmm2, imm8	EVEX.128.66.0F3A.W0 14 /r ib	AVX512BW
VPEXTRB r64/m8, xmm2, imm8	EVEX.128.66.0F3A.W1 14 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpextrd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpextrd<T, U, V>, 

VPEXTRD instruction

Instruction	Opcode	CPUID
VPEXTRD r/m32, xmm2, imm8	VEX.128.66.0F3A.W0 16 /r ib	AVX
VPEXTRD r/m32, xmm2, imm8	EVEX.128.66.0F3A.W0 16 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpextrq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpextrq<T, U, V>, 

VPEXTRQ instruction

Instruction	Opcode	CPUID
VPEXTRQ r/m64, xmm2, imm8	VEX.128.66.0F3A.W1 16 /r ib	AVX
VPEXTRQ r/m64, xmm2, imm8	EVEX.128.66.0F3A.W1 16 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpextrw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpextrw<T, U, V>, 

VPEXTRW instruction

Instruction	Opcode	CPUID
VPEXTRW r32, xmm1, imm8	VEX.128.66.0F.W0 C5 /r ib	AVX
VPEXTRW r64, xmm1, imm8	VEX.128.66.0F.W1 C5 /r ib	AVX
VPEXTRW r32, xmm1, imm8	EVEX.128.66.0F.W0 C5 /r ib	AVX512BW
VPEXTRW r64, xmm1, imm8	EVEX.128.66.0F.W1 C5 /r ib	AVX512BW
VPEXTRW r32/m16, xmm2, imm8	VEX.128.66.0F3A.W0 15 /r ib	AVX
VPEXTRW r32/m16, xmm2, imm8	EVEX.128.66.0F3A.W0 15 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpgatherdd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpgatherdd<T, U>, 

VPGATHERDD instruction

Instruction	Opcode	CPUID
VPGATHERDD xmm1 {k1}, vm32x	EVEX.128.66.0F38.W0 90 /vsib	AVX512VL AVX512F
VPGATHERDD ymm1 {k1}, vm32y	EVEX.256.66.0F38.W0 90 /vsib	AVX512VL AVX512F
VPGATHERDD zmm1 {k1}, vm32z	EVEX.512.66.0F38.W0 90 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpgatherdd_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpgatherdd3<T, U, V>, 

VPGATHERDD instruction

Instruction	Opcode	CPUID
VPGATHERDD xmm1, vm32x, xmm2	VEX.128.66.0F38.W0 90 /r	AVX2
VPGATHERDD ymm1, vm32y, ymm2	VEX.256.66.0F38.W0 90 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpgatherdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpgatherdq<T, U>, 

VPGATHERDQ instruction

Instruction	Opcode	CPUID
VPGATHERDQ xmm1 {k1}, vm32x	EVEX.128.66.0F38.W1 90 /vsib	AVX512VL AVX512F
VPGATHERDQ ymm1 {k1}, vm32x	EVEX.256.66.0F38.W1 90 /vsib	AVX512VL AVX512F
VPGATHERDQ zmm1 {k1}, vm32y	EVEX.512.66.0F38.W1 90 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpgatherdq_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpgatherdq3<T, U, V>, 

VPGATHERDQ instruction

Instruction	Opcode	CPUID
VPGATHERDQ xmm1, vm32x, xmm2	VEX.128.66.0F38.W1 90 /r	AVX2
VPGATHERDQ ymm1, vm32x, ymm2	VEX.256.66.0F38.W1 90 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpgatherqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpgatherqd<T, U>, 

VPGATHERQD instruction

Instruction	Opcode	CPUID
VPGATHERQD xmm1 {k1}, vm64x	EVEX.128.66.0F38.W0 91 /vsib	AVX512VL AVX512F
VPGATHERQD xmm1 {k1}, vm64y	EVEX.256.66.0F38.W0 91 /vsib	AVX512VL AVX512F
VPGATHERQD ymm1 {k1}, vm64z	EVEX.512.66.0F38.W0 91 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpgatherqd_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpgatherqd3<T, U, V>, 

VPGATHERQD instruction

Instruction	Opcode	CPUID
VPGATHERQD xmm1, vm64x, xmm2	VEX.128.66.0F38.W0 91 /r	AVX2
VPGATHERQD xmm1, vm64y, xmm2	VEX.256.66.0F38.W0 91 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpgatherqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpgatherqq<T, U>, 

VPGATHERQQ instruction

Instruction	Opcode	CPUID
VPGATHERQQ xmm1 {k1}, vm64x	EVEX.128.66.0F38.W1 91 /vsib	AVX512VL AVX512F
VPGATHERQQ ymm1 {k1}, vm64y	EVEX.256.66.0F38.W1 91 /vsib	AVX512VL AVX512F
VPGATHERQQ zmm1 {k1}, vm64z	EVEX.512.66.0F38.W1 91 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpgatherqq_3<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpgatherqq3<T, U, V>, 

VPGATHERQQ instruction

Instruction	Opcode	CPUID
VPGATHERQQ xmm1, vm64x, xmm2	VEX.128.66.0F38.W1 91 /r	AVX2
VPGATHERQQ ymm1, vm64y, ymm2	VEX.256.66.0F38.W1 91 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vphaddbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphaddbd<T, U>, 

VPHADDBD instruction

Instruction	Opcode	CPUID
VPHADDBD xmm1, xmm2/m128	XOP.128.X9.W0 C2 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphaddbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphaddbq<T, U>, 

VPHADDBQ instruction

Instruction	Opcode	CPUID
VPHADDBQ xmm1, xmm2/m128	XOP.128.X9.W0 C3 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphaddbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphaddbw<T, U>, 

VPHADDBW instruction

Instruction	Opcode	CPUID
VPHADDBW xmm1, xmm2/m128	XOP.128.X9.W0 C1 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphaddd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVphaddd<T, U, V>, 

VPHADDD instruction

Instruction	Opcode	CPUID
VPHADDD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 02 /r	AVX
VPHADDD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 02 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vphadddq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphadddq<T, U>, 

VPHADDDQ instruction

Instruction	Opcode	CPUID
VPHADDDQ xmm1, xmm2/m128	XOP.128.X9.W0 CB /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphaddsw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVphaddsw<T, U, V>, 

VPHADDSW instruction

Instruction	Opcode	CPUID
VPHADDSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 03 /r	AVX
VPHADDSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 03 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vphaddubd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphaddubd<T, U>, 

VPHADDUBD instruction

Instruction	Opcode	CPUID
VPHADDUBD xmm1, xmm2/m128	XOP.128.X9.W0 D2 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphaddubq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphaddubq<T, U>, 

VPHADDUBQ instruction

Instruction	Opcode	CPUID
VPHADDUBQ xmm1, xmm2/m128	XOP.128.X9.W0 D3 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphaddubw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphaddubw<T, U>, 

VPHADDUBW instruction

Instruction	Opcode	CPUID
VPHADDUBW xmm1, xmm2/m128	XOP.128.X9.W0 D1 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphaddudq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphaddudq<T, U>, 

VPHADDUDQ instruction

Instruction	Opcode	CPUID
VPHADDUDQ xmm1, xmm2/m128	XOP.128.X9.W0 DB /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphadduwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphadduwd<T, U>, 

VPHADDUWD instruction

Instruction	Opcode	CPUID
VPHADDUWD xmm1, xmm2/m128	XOP.128.X9.W0 D6 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphadduwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphadduwq<T, U>, 

VPHADDUWQ instruction

Instruction	Opcode	CPUID
VPHADDUWQ xmm1, xmm2/m128	XOP.128.X9.W0 D7 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphaddw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVphaddw<T, U, V>, 

VPHADDW instruction

Instruction	Opcode	CPUID
VPHADDW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 01 /r	AVX
VPHADDW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 01 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vphaddwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphaddwd<T, U>, 

VPHADDWD instruction

Instruction	Opcode	CPUID
VPHADDWD xmm1, xmm2/m128	XOP.128.X9.W0 C6 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphaddwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphaddwq<T, U>, 

VPHADDWQ instruction

Instruction	Opcode	CPUID
VPHADDWQ xmm1, xmm2/m128	XOP.128.X9.W0 C7 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphminposuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphminposuw<T, U>, 

VPHMINPOSUW instruction

Instruction	Opcode	CPUID
VPHMINPOSUW xmm1, xmm2/m128	VEX.128.66.0F38.WIG 41 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphsubbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphsubbw<T, U>, 

VPHSUBBW instruction

Instruction	Opcode	CPUID
VPHSUBBW xmm1, xmm2/m128	XOP.128.X9.W0 E1 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphsubd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVphsubd<T, U, V>, 

VPHSUBD instruction

Instruction	Opcode	CPUID
VPHSUBD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 06 /r	AVX
VPHSUBD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 06 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vphsubdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphsubdq<T, U>, 

VPHSUBDQ instruction

Instruction	Opcode	CPUID
VPHSUBDQ xmm1, xmm2/m128	XOP.128.X9.W0 E3 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vphsubsw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVphsubsw<T, U, V>, 

VPHSUBSW instruction

Instruction	Opcode	CPUID
VPHSUBSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 07 /r	AVX
VPHSUBSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 07 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vphsubw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVphsubw<T, U, V>, 

VPHSUBW instruction

Instruction	Opcode	CPUID
VPHSUBW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 05 /r	AVX
VPHSUBW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 05 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vphsubwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVphsubwd<T, U>, 

VPHSUBWD instruction

Instruction	Opcode	CPUID
VPHSUBWD xmm1, xmm2/m128	XOP.128.X9.W0 E2 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpinsrb<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpinsrb<T, U, V, W>, 

VPINSRB instruction

Instruction	Opcode	CPUID
VPINSRB xmm1, xmm2, r32/m8, imm8	VEX.128.66.0F3A.W0 20 /r ib	AVX
VPINSRB xmm1, xmm2, r64/m8, imm8	VEX.128.66.0F3A.W1 20 /r ib	AVX
VPINSRB xmm1, xmm2, r32/m8, imm8	EVEX.128.66.0F3A.W0 20 /r ib	AVX512BW
VPINSRB xmm1, xmm2, r64/m8, imm8	EVEX.128.66.0F3A.W1 20 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpinsrd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpinsrd<T, U, V, W>, 

VPINSRD instruction

Instruction	Opcode	CPUID
VPINSRD xmm1, xmm2, r/m32, imm8	VEX.128.66.0F3A.W0 22 /r ib	AVX
VPINSRD xmm1, xmm2, r/m32, imm8	EVEX.128.66.0F3A.W0 22 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpinsrq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpinsrq<T, U, V, W>, 

VPINSRQ instruction

Instruction	Opcode	CPUID
VPINSRQ xmm1, xmm2, r/m64, imm8	VEX.128.66.0F3A.W1 22 /r ib	AVX
VPINSRQ xmm1, xmm2, r/m64, imm8	EVEX.128.66.0F3A.W1 22 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpinsrw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpinsrw<T, U, V, W>, 

VPINSRW instruction

Instruction	Opcode	CPUID
VPINSRW xmm1, xmm2, r32/m16, imm8	VEX.128.66.0F.W0 C4 /r ib	AVX
VPINSRW xmm1, xmm2, r64/m16, imm8	VEX.128.66.0F.W1 C4 /r ib	AVX
VPINSRW xmm1, xmm2, r32/m16, imm8	EVEX.128.66.0F.W0 C4 /r ib	AVX512BW
VPINSRW xmm1, xmm2, r64/m16, imm8	EVEX.128.66.0F.W1 C4 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vplzcntd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVplzcntd<T, U>, 

VPLZCNTD instruction

Instruction	Opcode	CPUID
VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.0F38.W0 44 /r	AVX512VL AVX512CD
VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.0F38.W0 44 /r	AVX512VL AVX512CD
VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst	EVEX.512.66.0F38.W0 44 /r	AVX512CD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vplzcntq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVplzcntq<T, U>, 

VPLZCNTQ instruction

Instruction	Opcode	CPUID
VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F38.W1 44 /r	AVX512VL AVX512CD
VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F38.W1 44 /r	AVX512VL AVX512CD
VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst	EVEX.512.66.0F38.W1 44 /r	AVX512CD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmacsdd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacsdd<T, U, V, W>, 

VPMACSDD instruction

Instruction	Opcode	CPUID
VPMACSDD xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 9E /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmacsdqh<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacsdqh<T, U, V, W>, 

VPMACSDQH instruction

Instruction	Opcode	CPUID
VPMACSDQH xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 9F /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmacsdql<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacsdql<T, U, V, W>, 

VPMACSDQL instruction

Instruction	Opcode	CPUID
VPMACSDQL xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 97 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmacssdd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacssdd<T, U, V, W>, 

VPMACSSDD instruction

Instruction	Opcode	CPUID
VPMACSSDD xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 8E /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmacssdqh<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacssdqh<T, U, V, W>, 

VPMACSSDQH instruction

Instruction	Opcode	CPUID
VPMACSSDQH xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 8F /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmacssdql<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacssdql<T, U, V, W>, 

VPMACSSDQL instruction

Instruction	Opcode	CPUID
VPMACSSDQL xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 87 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmacsswd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacsswd<T, U, V, W>, 

VPMACSSWD instruction

Instruction	Opcode	CPUID
VPMACSSWD xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 86 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmacssww<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacssww<T, U, V, W>, 

VPMACSSWW instruction

Instruction	Opcode	CPUID
VPMACSSWW xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 85 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmacswd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacswd<T, U, V, W>, 

VPMACSWD instruction

Instruction	Opcode	CPUID
VPMACSWD xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 96 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmacsww<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmacsww<T, U, V, W>, 

VPMACSWW instruction

Instruction	Opcode	CPUID
VPMACSWW xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 95 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmadcsswd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmadcsswd<T, U, V, W>, 

VPMADCSSWD instruction

Instruction	Opcode	CPUID
VPMADCSSWD xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 A6 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmadcswd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpmadcswd<T, U, V, W>, 

VPMADCSWD instruction

Instruction	Opcode	CPUID
VPMADCSWD xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 B6 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpmadd52huq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmadd52huq<T, U, V>, 

VPMADD52HUQ instruction

Instruction	Opcode	CPUID
VPMADD52HUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 B5 /r	AVX512VL AVX512_IFMA
VPMADD52HUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 B5 /r	AVX512VL AVX512_IFMA
VPMADD52HUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 B5 /r	AVX512_IFMA

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmadd52luq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmadd52luq<T, U, V>, 

VPMADD52LUQ instruction

Instruction	Opcode	CPUID
VPMADD52LUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 B4 /r	AVX512VL AVX512_IFMA
VPMADD52LUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 B4 /r	AVX512VL AVX512_IFMA
VPMADD52LUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 B4 /r	AVX512_IFMA

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaddubsw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaddubsw<T, U, V>, 

VPMADDUBSW instruction

Instruction	Opcode	CPUID
VPMADDUBSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 04 /r	AVX
VPMADDUBSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 04 /r	AVX2
VPMADDUBSW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG 04 /r	AVX512VL AVX512BW
VPMADDUBSW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG 04 /r	AVX512VL AVX512BW
VPMADDUBSW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG 04 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaddwd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaddwd<T, U, V>, 

VPMADDWD instruction

Instruction	Opcode	CPUID
VPMADDWD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG F5 /r	AVX
VPMADDWD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG F5 /r	AVX2
VPMADDWD xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG F5 /r	AVX512VL AVX512BW
VPMADDWD ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG F5 /r	AVX512VL AVX512BW
VPMADDWD zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG F5 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaskmovd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaskmovd<T, U, V>, 

VPMASKMOVD instruction

Instruction	Opcode	CPUID
VPMASKMOVD xmm1, xmm2, m128	VEX.128.66.0F38.W0 8C /r	AVX2
VPMASKMOVD ymm1, ymm2, m256	VEX.256.66.0F38.W0 8C /r	AVX2
VPMASKMOVD m128, xmm1, xmm2	VEX.128.66.0F38.W0 8E /r	AVX2
VPMASKMOVD m256, ymm1, ymm2	VEX.256.66.0F38.W0 8E /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaskmovq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaskmovq<T, U, V>, 

VPMASKMOVQ instruction

Instruction	Opcode	CPUID
VPMASKMOVQ xmm1, xmm2, m128	VEX.128.66.0F38.W1 8C /r	AVX2
VPMASKMOVQ ymm1, ymm2, m256	VEX.256.66.0F38.W1 8C /r	AVX2
VPMASKMOVQ m128, xmm1, xmm2	VEX.128.66.0F38.W1 8E /r	AVX2
VPMASKMOVQ m256, ymm1, ymm2	VEX.256.66.0F38.W1 8E /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaxsb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaxsb<T, U, V>, 

VPMAXSB instruction

Instruction	Opcode	CPUID
VPMAXSB xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 3C /r	AVX
VPMAXSB ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 3C /r	AVX2
VPMAXSB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG 3C /r	AVX512VL AVX512BW
VPMAXSB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG 3C /r	AVX512VL AVX512BW
VPMAXSB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG 3C /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaxsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaxsd<T, U, V>, 

VPMAXSD instruction

Instruction	Opcode	CPUID
VPMAXSD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 3D /r	AVX
VPMAXSD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 3D /r	AVX2
VPMAXSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 3D /r	AVX512VL AVX512F
VPMAXSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 3D /r	AVX512VL AVX512F
VPMAXSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 3D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaxsq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaxsq<T, U, V>, 

VPMAXSQ instruction

Instruction	Opcode	CPUID
VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 3D /r	AVX512VL AVX512F
VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 3D /r	AVX512VL AVX512F
VPMAXSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 3D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaxsw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaxsw<T, U, V>, 

VPMAXSW instruction

Instruction	Opcode	CPUID
VPMAXSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG EE /r	AVX
VPMAXSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG EE /r	AVX2
VPMAXSW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG EE /r	AVX512VL AVX512BW
VPMAXSW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG EE /r	AVX512VL AVX512BW
VPMAXSW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG EE /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaxub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaxub<T, U, V>, 

VPMAXUB instruction

Instruction	Opcode	CPUID
VPMAXUB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG DE /r	AVX
VPMAXUB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG DE /r	AVX2
VPMAXUB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG DE /r	AVX512VL AVX512BW
VPMAXUB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG DE /r	AVX512VL AVX512BW
VPMAXUB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG DE /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaxud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaxud<T, U, V>, 

VPMAXUD instruction

Instruction	Opcode	CPUID
VPMAXUD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 3F /r	AVX
VPMAXUD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 3F /r	AVX2
VPMAXUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 3F /r	AVX512VL AVX512F
VPMAXUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 3F /r	AVX512VL AVX512F
VPMAXUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 3F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaxuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaxuq<T, U, V>, 

VPMAXUQ instruction

Instruction	Opcode	CPUID
VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 3F /r	AVX512VL AVX512F
VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 3F /r	AVX512VL AVX512F
VPMAXUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 3F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmaxuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmaxuw<T, U, V>, 

VPMAXUW instruction

Instruction	Opcode	CPUID
VPMAXUW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 3E /r	AVX
VPMAXUW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 3E /r	AVX2
VPMAXUW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG 3E /r	AVX512VL AVX512BW
VPMAXUW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG 3E /r	AVX512VL AVX512BW
VPMAXUW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG 3E /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpminsb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpminsb<T, U, V>, 

VPMINSB instruction

Instruction	Opcode	CPUID
VPMINSB xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 38 /r	AVX
VPMINSB ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 38 /r	AVX2
VPMINSB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG 38 /r	AVX512VL AVX512BW
VPMINSB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG 38 /r	AVX512VL AVX512BW
VPMINSB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG 38 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpminsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpminsd<T, U, V>, 

VPMINSD instruction

Instruction	Opcode	CPUID
VPMINSD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 39 /r	AVX
VPMINSD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 39 /r	AVX2
VPMINSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 39 /r	AVX512VL AVX512F
VPMINSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 39 /r	AVX512VL AVX512F
VPMINSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 39 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpminsq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpminsq<T, U, V>, 

VPMINSQ instruction

Instruction	Opcode	CPUID
VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 39 /r	AVX512VL AVX512F
VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 39 /r	AVX512VL AVX512F
VPMINSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 39 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpminsw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpminsw<T, U, V>, 

VPMINSW instruction

Instruction	Opcode	CPUID
VPMINSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG EA /r	AVX
VPMINSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG EA /r	AVX2
VPMINSW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG EA /r	AVX512VL AVX512BW
VPMINSW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG EA /r	AVX512VL AVX512BW
VPMINSW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG EA /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpminub<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpminub<T, U, V>, 

VPMINUB instruction

Instruction	Opcode	CPUID
VPMINUB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG DA /r	AVX
VPMINUB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG DA /r	AVX2
VPMINUB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG DA /r	AVX512VL AVX512BW
VPMINUB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG DA /r	AVX512VL AVX512BW
VPMINUB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG DA /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpminud<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpminud<T, U, V>, 

VPMINUD instruction

Instruction	Opcode	CPUID
VPMINUD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 3B /r	AVX
VPMINUD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 3B /r	AVX2
VPMINUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 3B /r	AVX512VL AVX512F
VPMINUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 3B /r	AVX512VL AVX512F
VPMINUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 3B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpminuq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpminuq<T, U, V>, 

VPMINUQ instruction

Instruction	Opcode	CPUID
VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 3B /r	AVX512VL AVX512F
VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 3B /r	AVX512VL AVX512F
VPMINUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 3B /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpminuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpminuw<T, U, V>, 

VPMINUW instruction

Instruction	Opcode	CPUID
VPMINUW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 3A /r	AVX
VPMINUW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 3A /r	AVX2
VPMINUW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG 3A /r	AVX512VL AVX512BW
VPMINUW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG 3A /r	AVX512VL AVX512BW
VPMINUW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG 3A /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmovb2m<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovb2m<T, U>, 

VPMOVB2M instruction

Instruction	Opcode	CPUID
VPMOVB2M k1, xmm1	EVEX.128.F3.0F38.W0 29 /r	AVX512VL AVX512BW
VPMOVB2M k1, ymm1	EVEX.256.F3.0F38.W0 29 /r	AVX512VL AVX512BW
VPMOVB2M k1, zmm1	EVEX.512.F3.0F38.W0 29 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovd2m<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovd2m<T, U>, 

VPMOVD2M instruction

Instruction	Opcode	CPUID
VPMOVD2M k1, xmm1	EVEX.128.F3.0F38.W0 39 /r	AVX512VL AVX512DQ
VPMOVD2M k1, ymm1	EVEX.256.F3.0F38.W0 39 /r	AVX512VL AVX512DQ
VPMOVD2M k1, zmm1	EVEX.512.F3.0F38.W0 39 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovdb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovdb<T, U>, 

VPMOVDB instruction

Instruction	Opcode	CPUID
VPMOVDB xmm1/m32 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 31 /r	AVX512VL AVX512F
VPMOVDB xmm1/m64 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 31 /r	AVX512VL AVX512F
VPMOVDB xmm1/m128 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 31 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovdw<T, U>, 

VPMOVDW instruction

Instruction	Opcode	CPUID
VPMOVDW xmm1/m64 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 33 /r	AVX512VL AVX512F
VPMOVDW xmm1/m128 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 33 /r	AVX512VL AVX512F
VPMOVDW ymm1/m256 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 33 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovm2b<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovm2b<T, U>, 

VPMOVM2B instruction

Instruction	Opcode	CPUID
VPMOVM2B xmm1, k1	EVEX.128.F3.0F38.W0 28 /r	AVX512VL AVX512BW
VPMOVM2B ymm1, k1	EVEX.256.F3.0F38.W0 28 /r	AVX512VL AVX512BW
VPMOVM2B zmm1, k1	EVEX.512.F3.0F38.W0 28 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovm2d<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovm2d<T, U>, 

VPMOVM2D instruction

Instruction	Opcode	CPUID
VPMOVM2D xmm1, k1	EVEX.128.F3.0F38.W0 38 /r	AVX512VL AVX512DQ
VPMOVM2D ymm1, k1	EVEX.256.F3.0F38.W0 38 /r	AVX512VL AVX512DQ
VPMOVM2D zmm1, k1	EVEX.512.F3.0F38.W0 38 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovm2q<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovm2q<T, U>, 

VPMOVM2Q instruction

Instruction	Opcode	CPUID
VPMOVM2Q xmm1, k1	EVEX.128.F3.0F38.W1 38 /r	AVX512VL AVX512DQ
VPMOVM2Q ymm1, k1	EVEX.256.F3.0F38.W1 38 /r	AVX512VL AVX512DQ
VPMOVM2Q zmm1, k1	EVEX.512.F3.0F38.W1 38 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovm2w<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovm2w<T, U>, 

VPMOVM2W instruction

Instruction	Opcode	CPUID
VPMOVM2W xmm1, k1	EVEX.128.F3.0F38.W1 28 /r	AVX512VL AVX512BW
VPMOVM2W ymm1, k1	EVEX.256.F3.0F38.W1 28 /r	AVX512VL AVX512BW
VPMOVM2W zmm1, k1	EVEX.512.F3.0F38.W1 28 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovmskb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovmskb<T, U>, 

VPMOVMSKB instruction

Instruction	Opcode	CPUID
VPMOVMSKB r32, xmm1	VEX.128.66.0F.W0 D7 /r	AVX
VPMOVMSKB r32, ymm1	VEX.256.66.0F.W0 D7 /r	AVX2
VPMOVMSKB r64, xmm1	VEX.128.66.0F.W1 D7 /r	AVX
VPMOVMSKB r64, ymm1	VEX.256.66.0F.W1 D7 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovq2m<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovq2m<T, U>, 

VPMOVQ2M instruction

Instruction	Opcode	CPUID
VPMOVQ2M k1, xmm1	EVEX.128.F3.0F38.W1 39 /r	AVX512VL AVX512DQ
VPMOVQ2M k1, ymm1	EVEX.256.F3.0F38.W1 39 /r	AVX512VL AVX512DQ
VPMOVQ2M k1, zmm1	EVEX.512.F3.0F38.W1 39 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovqb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovqb<T, U>, 

VPMOVQB instruction

Instruction	Opcode	CPUID
VPMOVQB xmm1/m16 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 32 /r	AVX512VL AVX512F
VPMOVQB xmm1/m32 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 32 /r	AVX512VL AVX512F
VPMOVQB xmm1/m64 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 32 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovqd<T, U>, 

VPMOVQD instruction

Instruction	Opcode	CPUID
VPMOVQD xmm1/m64 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 35 /r	AVX512VL AVX512F
VPMOVQD xmm1/m128 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 35 /r	AVX512VL AVX512F
VPMOVQD ymm1/m256 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 35 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovqw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovqw<T, U>, 

VPMOVQW instruction

Instruction	Opcode	CPUID
VPMOVQW xmm1/m32 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 34 /r	AVX512VL AVX512F
VPMOVQW xmm1/m64 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 34 /r	AVX512VL AVX512F
VPMOVQW xmm1/m128 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 34 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsdb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsdb<T, U>, 

VPMOVSDB instruction

Instruction	Opcode	CPUID
VPMOVSDB xmm1/m32 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 21 /r	AVX512VL AVX512F
VPMOVSDB xmm1/m64 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 21 /r	AVX512VL AVX512F
VPMOVSDB xmm1/m128 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 21 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsdw<T, U>, 

VPMOVSDW instruction

Instruction	Opcode	CPUID
VPMOVSDW xmm1/m64 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 23 /r	AVX512VL AVX512F
VPMOVSDW xmm1/m128 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 23 /r	AVX512VL AVX512F
VPMOVSDW ymm1/m256 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 23 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsqb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsqb<T, U>, 

VPMOVSQB instruction

Instruction	Opcode	CPUID
VPMOVSQB xmm1/m16 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 22 /r	AVX512VL AVX512F
VPMOVSQB xmm1/m32 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 22 /r	AVX512VL AVX512F
VPMOVSQB xmm1/m64 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 22 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsqd<T, U>, 

VPMOVSQD instruction

Instruction	Opcode	CPUID
VPMOVSQD xmm1/m64 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 25 /r	AVX512VL AVX512F
VPMOVSQD xmm1/m128 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 25 /r	AVX512VL AVX512F
VPMOVSQD ymm1/m256 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 25 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsqw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsqw<T, U>, 

VPMOVSQW instruction

Instruction	Opcode	CPUID
VPMOVSQW xmm1/m32 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 24 /r	AVX512VL AVX512F
VPMOVSQW xmm1/m64 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 24 /r	AVX512VL AVX512F
VPMOVSQW xmm1/m128 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 24 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovswb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovswb<T, U>, 

VPMOVSWB instruction

Instruction	Opcode	CPUID
VPMOVSWB xmm1/m64 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 20 /r	AVX512VL AVX512BW
VPMOVSWB xmm1/m128 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 20 /r	AVX512VL AVX512BW
VPMOVSWB ymm1/m256 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 20 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsxbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsxbd<T, U>, 

VPMOVSXBD instruction

Instruction	Opcode	CPUID
VPMOVSXBD xmm1, xmm2/m32	VEX.128.66.0F38.WIG 21 /r	AVX
VPMOVSXBD ymm1, xmm2/m64	VEX.256.66.0F38.WIG 21 /r	AVX2
VPMOVSXBD xmm1 {k1}{z}, xmm2/m32	EVEX.128.66.0F38.WIG 21 /r	AVX512VL AVX512F
VPMOVSXBD ymm1 {k1}{z}, xmm2/m64	EVEX.256.66.0F38.WIG 21 /r	AVX512VL AVX512F
VPMOVSXBD zmm1 {k1}{z}, xmm2/m128	EVEX.512.66.0F38.WIG 21 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsxbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsxbq<T, U>, 

VPMOVSXBQ instruction

Instruction	Opcode	CPUID
VPMOVSXBQ xmm1, xmm2/m16	VEX.128.66.0F38.WIG 22 /r	AVX
VPMOVSXBQ ymm1, xmm2/m32	VEX.256.66.0F38.WIG 22 /r	AVX2
VPMOVSXBQ xmm1 {k1}{z}, xmm2/m16	EVEX.128.66.0F38.WIG 22 /r	AVX512VL AVX512F
VPMOVSXBQ ymm1 {k1}{z}, xmm2/m32	EVEX.256.66.0F38.WIG 22 /r	AVX512VL AVX512F
VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64	EVEX.512.66.0F38.WIG 22 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsxbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsxbw<T, U>, 

VPMOVSXBW instruction

Instruction	Opcode	CPUID
VPMOVSXBW xmm1, xmm2/m64	VEX.128.66.0F38.WIG 20 /r	AVX
VPMOVSXBW ymm1, xmm2/m128	VEX.256.66.0F38.WIG 20 /r	AVX2
VPMOVSXBW xmm1 {k1}{z}, xmm2/m64	EVEX.128.66.0F38.WIG 20 /r	AVX512VL AVX512BW
VPMOVSXBW ymm1 {k1}{z}, xmm2/m128	EVEX.256.66.0F38.WIG 20 /r	AVX512VL AVX512BW
VPMOVSXBW zmm1 {k1}{z}, ymm2/m256	EVEX.512.66.0F38.WIG 20 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsxdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsxdq<T, U>, 

VPMOVSXDQ instruction

Instruction	Opcode	CPUID
VPMOVSXDQ xmm1, xmm2/m64	VEX.128.66.0F38.WIG 25 /r	AVX
VPMOVSXDQ ymm1, xmm2/m128	VEX.256.66.0F38.WIG 25 /r	AVX2
VPMOVSXDQ xmm1 {k1}{z}, xmm2/m64	EVEX.128.66.0F38.W0 25 /r	AVX512VL AVX512F
VPMOVSXDQ ymm1 {k1}{z}, xmm2/m128	EVEX.256.66.0F38.W0 25 /r	AVX512VL AVX512F
VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256	EVEX.512.66.0F38.W0 25 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsxwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsxwd<T, U>, 

VPMOVSXWD instruction

Instruction	Opcode	CPUID
VPMOVSXWD xmm1, xmm2/m64	VEX.128.66.0F38.WIG 23 /r	AVX
VPMOVSXWD ymm1, xmm2/m128	VEX.256.66.0F38.WIG 23 /r	AVX2
VPMOVSXWD xmm1 {k1}{z}, xmm2/m64	EVEX.128.66.0F38.WIG 23 /r	AVX512VL AVX512F
VPMOVSXWD ymm1 {k1}{z}, xmm2/m128	EVEX.256.66.0F38.WIG 23 /r	AVX512VL AVX512F
VPMOVSXWD zmm1 {k1}{z}, ymm2/m256	EVEX.512.66.0F38.WIG 23 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovsxwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovsxwq<T, U>, 

VPMOVSXWQ instruction

Instruction	Opcode	CPUID
VPMOVSXWQ xmm1, xmm2/m32	VEX.128.66.0F38.WIG 24 /r	AVX
VPMOVSXWQ ymm1, xmm2/m64	VEX.256.66.0F38.WIG 24 /r	AVX2
VPMOVSXWQ xmm1 {k1}{z}, xmm2/m32	EVEX.128.66.0F38.WIG 24 /r	AVX512VL AVX512F
VPMOVSXWQ ymm1 {k1}{z}, xmm2/m64	EVEX.256.66.0F38.WIG 24 /r	AVX512VL AVX512F
VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128	EVEX.512.66.0F38.WIG 24 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovusdb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovusdb<T, U>, 

VPMOVUSDB instruction

Instruction	Opcode	CPUID
VPMOVUSDB xmm1/m32 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 11 /r	AVX512VL AVX512F
VPMOVUSDB xmm1/m64 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 11 /r	AVX512VL AVX512F
VPMOVUSDB xmm1/m128 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 11 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovusdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovusdw<T, U>, 

VPMOVUSDW instruction

Instruction	Opcode	CPUID
VPMOVUSDW xmm1/m64 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 13 /r	AVX512VL AVX512F
VPMOVUSDW xmm1/m128 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 13 /r	AVX512VL AVX512F
VPMOVUSDW ymm1/m256 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 13 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovusqb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovusqb<T, U>, 

VPMOVUSQB instruction

Instruction	Opcode	CPUID
VPMOVUSQB xmm1/m16 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 12 /r	AVX512VL AVX512F
VPMOVUSQB xmm1/m32 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 12 /r	AVX512VL AVX512F
VPMOVUSQB xmm1/m64 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 12 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovusqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovusqd<T, U>, 

VPMOVUSQD instruction

Instruction	Opcode	CPUID
VPMOVUSQD xmm1/m64 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 15 /r	AVX512VL AVX512F
VPMOVUSQD xmm1/m128 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 15 /r	AVX512VL AVX512F
VPMOVUSQD ymm1/m256 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 15 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovusqw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovusqw<T, U>, 

VPMOVUSQW instruction

Instruction	Opcode	CPUID
VPMOVUSQW xmm1/m32 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 14 /r	AVX512VL AVX512F
VPMOVUSQW xmm1/m64 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 14 /r	AVX512VL AVX512F
VPMOVUSQW xmm1/m128 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 14 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovuswb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovuswb<T, U>, 

VPMOVUSWB instruction

Instruction	Opcode	CPUID
VPMOVUSWB xmm1/m64 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 10 /r	AVX512VL AVX512BW
VPMOVUSWB xmm1/m128 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 10 /r	AVX512VL AVX512BW
VPMOVUSWB ymm1/m256 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 10 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovw2m<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovw2m<T, U>, 

VPMOVW2M instruction

Instruction	Opcode	CPUID
VPMOVW2M k1, xmm1	EVEX.128.F3.0F38.W1 29 /r	AVX512VL AVX512BW
VPMOVW2M k1, ymm1	EVEX.256.F3.0F38.W1 29 /r	AVX512VL AVX512BW
VPMOVW2M k1, zmm1	EVEX.512.F3.0F38.W1 29 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovwb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovwb<T, U>, 

VPMOVWB instruction

Instruction	Opcode	CPUID
VPMOVWB xmm1/m64 {k1}{z}, xmm2	EVEX.128.F3.0F38.W0 30 /r	AVX512VL AVX512BW
VPMOVWB xmm1/m128 {k1}{z}, ymm2	EVEX.256.F3.0F38.W0 30 /r	AVX512VL AVX512BW
VPMOVWB ymm1/m256 {k1}{z}, zmm2	EVEX.512.F3.0F38.W0 30 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovzxbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovzxbd<T, U>, 

VPMOVZXBD instruction

Instruction	Opcode	CPUID
VPMOVZXBD xmm1, xmm2/m32	VEX.128.66.0F38.WIG 31 /r	AVX
VPMOVZXBD ymm1, xmm2/m64	VEX.256.66.0F38.WIG 31 /r	AVX2
VPMOVZXBD xmm1 {k1}{z}, xmm2/m32	EVEX.128.66.0F38.WIG 31 /r	AVX512VL AVX512F
VPMOVZXBD ymm1 {k1}{z}, xmm2/m64	EVEX.256.66.0F38.WIG 31 /r	AVX512VL AVX512F
VPMOVZXBD zmm1 {k1}{z}, xmm2/m128	EVEX.512.66.0F38.WIG 31 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovzxbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovzxbq<T, U>, 

VPMOVZXBQ instruction

Instruction	Opcode	CPUID
VPMOVZXBQ xmm1, xmm2/m16	VEX.128.66.0F38.WIG 32 /r	AVX
VPMOVZXBQ ymm1, xmm2/m32	VEX.256.66.0F38.WIG 32 /r	AVX2
VPMOVZXBQ xmm1 {k1}{z}, xmm2/m16	EVEX.128.66.0F38.WIG 32 /r	AVX512VL AVX512F
VPMOVZXBQ ymm1 {k1}{z}, xmm2/m32	EVEX.256.66.0F38.WIG 32 /r	AVX512VL AVX512F
VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64	EVEX.512.66.0F38.WIG 32 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovzxbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovzxbw<T, U>, 

VPMOVZXBW instruction

Instruction	Opcode	CPUID
VPMOVZXBW xmm1, xmm2/m64	VEX.128.66.0F38.WIG 30 /r	AVX
VPMOVZXBW ymm1, xmm2/m128	VEX.256.66.0F38.WIG 30 /r	AVX2
VPMOVZXBW xmm1 {k1}{z}, xmm2/m64	EVEX.128.66.0F38.WIG 30 /r	AVX512VL AVX512BW
VPMOVZXBW ymm1 {k1}{z}, xmm2/m128	EVEX.256.66.0F38.WIG 30 /r	AVX512VL AVX512BW
VPMOVZXBW zmm1 {k1}{z}, ymm2/m256	EVEX.512.66.0F38.WIG 30 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovzxdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovzxdq<T, U>, 

VPMOVZXDQ instruction

Instruction	Opcode	CPUID
VPMOVZXDQ xmm1, xmm2/m64	VEX.128.66.0F38.WIG 35 /r	AVX
VPMOVZXDQ ymm1, xmm2/m128	VEX.256.66.0F38.WIG 35 /r	AVX2
VPMOVZXDQ xmm1 {k1}{z}, xmm2/m64	EVEX.128.66.0F38.W0 35 /r	AVX512VL AVX512F
VPMOVZXDQ ymm1 {k1}{z}, xmm2/m128	EVEX.256.66.0F38.W0 35 /r	AVX512VL AVX512F
VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256	EVEX.512.66.0F38.W0 35 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovzxwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovzxwd<T, U>, 

VPMOVZXWD instruction

Instruction	Opcode	CPUID
VPMOVZXWD xmm1, xmm2/m64	VEX.128.66.0F38.WIG 33 /r	AVX
VPMOVZXWD ymm1, xmm2/m128	VEX.256.66.0F38.WIG 33 /r	AVX2
VPMOVZXWD xmm1 {k1}{z}, xmm2/m64	EVEX.128.66.0F38.WIG 33 /r	AVX512VL AVX512F
VPMOVZXWD ymm1 {k1}{z}, xmm2/m128	EVEX.256.66.0F38.WIG 33 /r	AVX512VL AVX512F
VPMOVZXWD zmm1 {k1}{z}, ymm2/m256	EVEX.512.66.0F38.WIG 33 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmovzxwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpmovzxwq<T, U>, 

VPMOVZXWQ instruction

Instruction	Opcode	CPUID
VPMOVZXWQ xmm1, xmm2/m32	VEX.128.66.0F38.WIG 34 /r	AVX
VPMOVZXWQ ymm1, xmm2/m64	VEX.256.66.0F38.WIG 34 /r	AVX2
VPMOVZXWQ xmm1 {k1}{z}, xmm2/m32	EVEX.128.66.0F38.WIG 34 /r	AVX512VL AVX512F
VPMOVZXWQ ymm1 {k1}{z}, xmm2/m64	EVEX.256.66.0F38.WIG 34 /r	AVX512VL AVX512F
VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128	EVEX.512.66.0F38.WIG 34 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpmuldq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmuldq<T, U, V>, 

VPMULDQ instruction

Instruction	Opcode	CPUID
VPMULDQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 28 /r	AVX
VPMULDQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 28 /r	AVX2
VPMULDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 28 /r	AVX512VL AVX512F
VPMULDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 28 /r	AVX512VL AVX512F
VPMULDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 28 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmulhrsw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmulhrsw<T, U, V>, 

VPMULHRSW instruction

Instruction	Opcode	CPUID
VPMULHRSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 0B /r	AVX
VPMULHRSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 0B /r	AVX2
VPMULHRSW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG 0B /r	AVX512VL AVX512BW
VPMULHRSW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG 0B /r	AVX512VL AVX512BW
VPMULHRSW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG 0B /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmulhuw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmulhuw<T, U, V>, 

VPMULHUW instruction

Instruction	Opcode	CPUID
VPMULHUW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG E4 /r	AVX
VPMULHUW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG E4 /r	AVX2
VPMULHUW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG E4 /r	AVX512VL AVX512BW
VPMULHUW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG E4 /r	AVX512VL AVX512BW
VPMULHUW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG E4 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmulhw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmulhw<T, U, V>, 

VPMULHW instruction

Instruction	Opcode	CPUID
VPMULHW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG E5 /r	AVX
VPMULHW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG E5 /r	AVX2
VPMULHW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG E5 /r	AVX512VL AVX512BW
VPMULHW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG E5 /r	AVX512VL AVX512BW
VPMULHW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG E5 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmulld<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmulld<T, U, V>, 

VPMULLD instruction

Instruction	Opcode	CPUID
VPMULLD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 40 /r	AVX
VPMULLD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 40 /r	AVX2
VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 40 /r	AVX512VL AVX512F
VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 40 /r	AVX512VL AVX512F
VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 40 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmullq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmullq<T, U, V>, 

VPMULLQ instruction

Instruction	Opcode	CPUID
VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 40 /r	AVX512VL AVX512DQ
VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 40 /r	AVX512VL AVX512DQ
VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 40 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmullw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmullw<T, U, V>, 

VPMULLW instruction

Instruction	Opcode	CPUID
VPMULLW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG D5 /r	AVX
VPMULLW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG D5 /r	AVX2
VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG D5 /r	AVX512VL AVX512BW
VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG D5 /r	AVX512VL AVX512BW
VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG D5 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmultishiftqb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmultishiftqb<T, U, V>, 

VPMULTISHIFTQB instruction

Instruction	Opcode	CPUID
VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 83 /r	AVX512VL AVX512_VBMI
VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 83 /r	AVX512VL AVX512_VBMI
VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 83 /r	AVX512_VBMI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpmuludq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpmuludq<T, U, V>, 

VPMULUDQ instruction

Instruction	Opcode	CPUID
VPMULUDQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG F4 /r	AVX
VPMULUDQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG F4 /r	AVX2
VPMULUDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 F4 /r	AVX512VL AVX512F
VPMULUDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 F4 /r	AVX512VL AVX512F
VPMULUDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 F4 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpopcntb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpopcntb<T, U>, 

VPOPCNTB instruction

Instruction	Opcode	CPUID
VPOPCNTB xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.W0 54 /r	AVX512VL AVX512_BITALG
VPOPCNTB ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.W0 54 /r	AVX512VL AVX512_BITALG
VPOPCNTB zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.W0 54 /r	AVX512_BITALG

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpopcntd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpopcntd<T, U>, 

VPOPCNTD instruction

Instruction	Opcode	CPUID
VPOPCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.0F38.W0 55 /r	AVX512VL AVX512_VPOPCNTDQ
VPOPCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.0F38.W0 55 /r	AVX512VL AVX512_VPOPCNTDQ
VPOPCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst	EVEX.512.66.0F38.W0 55 /r	AVX512_VPOPCNTDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpopcntq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpopcntq<T, U>, 

VPOPCNTQ instruction

Instruction	Opcode	CPUID
VPOPCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F38.W1 55 /r	AVX512VL AVX512_VPOPCNTDQ
VPOPCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F38.W1 55 /r	AVX512VL AVX512_VPOPCNTDQ
VPOPCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst	EVEX.512.66.0F38.W1 55 /r	AVX512_VPOPCNTDQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpopcntw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpopcntw<T, U>, 

VPOPCNTW instruction

Instruction	Opcode	CPUID
VPOPCNTW xmm1 {k1}{z}, xmm2/m128	EVEX.128.66.0F38.W1 54 /r	AVX512VL AVX512_BITALG
VPOPCNTW ymm1 {k1}{z}, ymm2/m256	EVEX.256.66.0F38.W1 54 /r	AVX512VL AVX512_BITALG
VPOPCNTW zmm1 {k1}{z}, zmm2/m512	EVEX.512.66.0F38.W1 54 /r	AVX512_BITALG

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpor<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError> where
    Self: CodeAsmVpor<T, U, V>, 

VPOR instruction

Instruction	Opcode	CPUID
VPOR xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG EB /r	AVX
VPOR ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG EB /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpord<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpord<T, U, V>, 

VPORD instruction

Instruction	Opcode	CPUID
VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 EB /r	AVX512VL AVX512F
VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 EB /r	AVX512VL AVX512F
VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 EB /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vporq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVporq<T, U, V>, 

VPORQ instruction

Instruction	Opcode	CPUID
VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 EB /r	AVX512VL AVX512F
VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 EB /r	AVX512VL AVX512F
VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 EB /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpperm<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpperm<T, U, V, W>, 

VPPERM instruction

Instruction	Opcode	CPUID
VPPERM xmm1, xmm2, xmm3/m128, xmm4	XOP.128.X8.W0 A3 /r /is4	XOP
VPPERM xmm1, xmm2, xmm3, xmm4/m128	XOP.128.X8.W1 A3 /r /is4	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vprold<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprold<T, U, V>, 

VPROLD instruction

Instruction	Opcode	CPUID
VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F.W0 72 /1 ib	AVX512VL AVX512F
VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F.W0 72 /1 ib	AVX512VL AVX512F
VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8	EVEX.512.66.0F.W0 72 /1 ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprolq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprolq<T, U, V>, 

VPROLQ instruction

Instruction	Opcode	CPUID
VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F.W1 72 /1 ib	AVX512VL AVX512F
VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F.W1 72 /1 ib	AVX512VL AVX512F
VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F.W1 72 /1 ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprolvd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprolvd<T, U, V>, 

VPROLVD instruction

Instruction	Opcode	CPUID
VPROLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 15 /r	AVX512VL AVX512F
VPROLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 15 /r	AVX512VL AVX512F
VPROLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 15 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprolvq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprolvq<T, U, V>, 

VPROLVQ instruction

Instruction	Opcode	CPUID
VPROLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 15 /r	AVX512VL AVX512F
VPROLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 15 /r	AVX512VL AVX512F
VPROLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 15 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprord<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprord<T, U, V>, 

VPRORD instruction

Instruction	Opcode	CPUID
VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F.W0 72 /0 ib	AVX512VL AVX512F
VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F.W0 72 /0 ib	AVX512VL AVX512F
VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8	EVEX.512.66.0F.W0 72 /0 ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprorq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprorq<T, U, V>, 

VPRORQ instruction

Instruction	Opcode	CPUID
VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F.W1 72 /0 ib	AVX512VL AVX512F
VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F.W1 72 /0 ib	AVX512VL AVX512F
VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F.W1 72 /0 ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprorvd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprorvd<T, U, V>, 

VPRORVD instruction

Instruction	Opcode	CPUID
VPRORVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 14 /r	AVX512VL AVX512F
VPRORVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 14 /r	AVX512VL AVX512F
VPRORVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 14 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprorvq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprorvq<T, U, V>, 

VPRORVQ instruction

Instruction	Opcode	CPUID
VPRORVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 14 /r	AVX512VL AVX512F
VPRORVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 14 /r	AVX512VL AVX512F
VPRORVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 14 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprotb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprotb<T, U, V>, 

VPROTB instruction

Instruction	Opcode	CPUID
VPROTB xmm1, xmm2/m128, imm8	XOP.128.X8.W0 C0 /r ib	XOP
VPROTB xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 90 /r	XOP
VPROTB xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 90 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprotd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprotd<T, U, V>, 

VPROTD instruction

Instruction	Opcode	CPUID
VPROTD xmm1, xmm2/m128, imm8	XOP.128.X8.W0 C2 /r ib	XOP
VPROTD xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 92 /r	XOP
VPROTD xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 92 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprotq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprotq<T, U, V>, 

VPROTQ instruction

Instruction	Opcode	CPUID
VPROTQ xmm1, xmm2/m128, imm8	XOP.128.X8.W0 C3 /r ib	XOP
VPROTQ xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 93 /r	XOP
VPROTQ xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 93 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vprotw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVprotw<T, U, V>, 

VPROTW instruction

Instruction	Opcode	CPUID
VPROTW xmm1, xmm2/m128, imm8	XOP.128.X8.W0 C1 /r ib	XOP
VPROTW xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 91 /r	XOP
VPROTW xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 91 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsadbw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsadbw<T, U, V>, 

VPSADBW instruction

Instruction	Opcode	CPUID
VPSADBW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG F6 /r	AVX
VPSADBW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG F6 /r	AVX2
VPSADBW xmm1, xmm2, xmm3/m128	EVEX.128.66.0F.WIG F6 /r	AVX512VL AVX512BW
VPSADBW ymm1, ymm2, ymm3/m256	EVEX.256.66.0F.WIG F6 /r	AVX512VL AVX512BW
VPSADBW zmm1, zmm2, zmm3/m512	EVEX.512.66.0F.WIG F6 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpscatterdd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpscatterdd<T, U>, 

VPSCATTERDD instruction

Instruction	Opcode	CPUID
VPSCATTERDD vm32x {k1}, xmm1	EVEX.128.66.0F38.W0 A0 /vsib	AVX512VL AVX512F
VPSCATTERDD vm32y {k1}, ymm1	EVEX.256.66.0F38.W0 A0 /vsib	AVX512VL AVX512F
VPSCATTERDD vm32z {k1}, zmm1	EVEX.512.66.0F38.W0 A0 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpscatterdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpscatterdq<T, U>, 

VPSCATTERDQ instruction

Instruction	Opcode	CPUID
VPSCATTERDQ vm32x {k1}, xmm1	EVEX.128.66.0F38.W1 A0 /vsib	AVX512VL AVX512F
VPSCATTERDQ vm32x {k1}, ymm1	EVEX.256.66.0F38.W1 A0 /vsib	AVX512VL AVX512F
VPSCATTERDQ vm32y {k1}, zmm1	EVEX.512.66.0F38.W1 A0 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpscatterqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpscatterqd<T, U>, 

VPSCATTERQD instruction

Instruction	Opcode	CPUID
VPSCATTERQD vm64x {k1}, xmm1	EVEX.128.66.0F38.W0 A1 /vsib	AVX512VL AVX512F
VPSCATTERQD vm64y {k1}, xmm1	EVEX.256.66.0F38.W0 A1 /vsib	AVX512VL AVX512F
VPSCATTERQD vm64z {k1}, ymm1	EVEX.512.66.0F38.W0 A1 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpscatterqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVpscatterqq<T, U>, 

VPSCATTERQQ instruction

Instruction	Opcode	CPUID
VPSCATTERQQ vm64x {k1}, xmm1	EVEX.128.66.0F38.W1 A1 /vsib	AVX512VL AVX512F
VPSCATTERQQ vm64y {k1}, ymm1	EVEX.256.66.0F38.W1 A1 /vsib	AVX512VL AVX512F
VPSCATTERQQ vm64z {k1}, zmm1	EVEX.512.66.0F38.W1 A1 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vpshab<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshab<T, U, V>, 

VPSHAB instruction

Instruction	Opcode	CPUID
VPSHAB xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 98 /r	XOP
VPSHAB xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 98 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshad<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshad<T, U, V>, 

VPSHAD instruction

Instruction	Opcode	CPUID
VPSHAD xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 9A /r	XOP
VPSHAD xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 9A /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshaq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshaq<T, U, V>, 

VPSHAQ instruction

Instruction	Opcode	CPUID
VPSHAQ xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 9B /r	XOP
VPSHAQ xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 9B /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshaw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshaw<T, U, V>, 

VPSHAW instruction

Instruction	Opcode	CPUID
VPSHAW xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 99 /r	XOP
VPSHAW xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 99 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshlb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshlb<T, U, V>, 

VPSHLB instruction

Instruction	Opcode	CPUID
VPSHLB xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 94 /r	XOP
VPSHLB xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 94 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshld<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshld<T, U, V>, 

VPSHLD instruction

Instruction	Opcode	CPUID
VPSHLD xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 96 /r	XOP
VPSHLD xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 96 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshldd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpshldd<T, U, V, W>, 

VPSHLDD instruction

Instruction	Opcode	CPUID
VPSHLDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 71 /r ib	AVX512VL AVX512_VBMI2
VPSHLDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 71 /r ib	AVX512VL AVX512_VBMI2
VPSHLDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 71 /r ib	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpshldq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpshldq<T, U, V, W>, 

VPSHLDQ instruction

Instruction	Opcode	CPUID
VPSHLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 71 /r ib	AVX512VL AVX512_VBMI2
VPSHLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 71 /r ib	AVX512VL AVX512_VBMI2
VPSHLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 71 /r ib	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpshldvd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshldvd<T, U, V>, 

VPSHLDVD instruction

Instruction	Opcode	CPUID
VPSHLDVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 71 /r	AVX512VL AVX512_VBMI2
VPSHLDVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 71 /r	AVX512VL AVX512_VBMI2
VPSHLDVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 71 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshldvq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshldvq<T, U, V>, 

VPSHLDVQ instruction

Instruction	Opcode	CPUID
VPSHLDVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 71 /r	AVX512VL AVX512_VBMI2
VPSHLDVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 71 /r	AVX512VL AVX512_VBMI2
VPSHLDVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 71 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshldvw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshldvw<T, U, V>, 

VPSHLDVW instruction

Instruction	Opcode	CPUID
VPSHLDVW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 70 /r	AVX512VL AVX512_VBMI2
VPSHLDVW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 70 /r	AVX512VL AVX512_VBMI2
VPSHLDVW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 70 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshldw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpshldw<T, U, V, W>, 

VPSHLDW instruction

Instruction	Opcode	CPUID
VPSHLDW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 70 /r ib	AVX512VL AVX512_VBMI2
VPSHLDW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 70 /r ib	AVX512VL AVX512_VBMI2
VPSHLDW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 70 /r ib	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpshlq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshlq<T, U, V>, 

VPSHLQ instruction

Instruction	Opcode	CPUID
VPSHLQ xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 97 /r	XOP
VPSHLQ xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 97 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshlw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshlw<T, U, V>, 

VPSHLW instruction

Instruction	Opcode	CPUID
VPSHLW xmm1, xmm2/m128, xmm3	XOP.128.X9.W0 95 /r	XOP
VPSHLW xmm1, xmm2, xmm3/m128	XOP.128.X9.W1 95 /r	XOP

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshrdd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpshrdd<T, U, V, W>, 

VPSHRDD instruction

Instruction	Opcode	CPUID
VPSHRDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 73 /r ib	AVX512VL AVX512_VBMI2
VPSHRDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 73 /r ib	AVX512VL AVX512_VBMI2
VPSHRDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 73 /r ib	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpshrdq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpshrdq<T, U, V, W>, 

VPSHRDQ instruction

Instruction	Opcode	CPUID
VPSHRDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 73 /r ib	AVX512VL AVX512_VBMI2
VPSHRDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 73 /r ib	AVX512VL AVX512_VBMI2
VPSHRDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 73 /r ib	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpshrdvd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshrdvd<T, U, V>, 

VPSHRDVD instruction

Instruction	Opcode	CPUID
VPSHRDVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 73 /r	AVX512VL AVX512_VBMI2
VPSHRDVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 73 /r	AVX512VL AVX512_VBMI2
VPSHRDVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 73 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshrdvq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshrdvq<T, U, V>, 

VPSHRDVQ instruction

Instruction	Opcode	CPUID
VPSHRDVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 73 /r	AVX512VL AVX512_VBMI2
VPSHRDVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 73 /r	AVX512VL AVX512_VBMI2
VPSHRDVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 73 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshrdvw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshrdvw<T, U, V>, 

VPSHRDVW instruction

Instruction	Opcode	CPUID
VPSHRDVW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 72 /r	AVX512VL AVX512_VBMI2
VPSHRDVW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 72 /r	AVX512VL AVX512_VBMI2
VPSHRDVW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 72 /r	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshrdw<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpshrdw<T, U, V, W>, 

VPSHRDW instruction

Instruction	Opcode	CPUID
VPSHRDW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8	EVEX.128.66.0F3A.W1 72 /r ib	AVX512VL AVX512_VBMI2
VPSHRDW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8	EVEX.256.66.0F3A.W1 72 /r ib	AVX512VL AVX512_VBMI2
VPSHRDW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8	EVEX.512.66.0F3A.W1 72 /r ib	AVX512_VBMI2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpshufb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshufb<T, U, V>, 

VPSHUFB instruction

Instruction	Opcode	CPUID
VPSHUFB xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 00 /r	AVX
VPSHUFB ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 00 /r	AVX2
VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.WIG 00 /r	AVX512VL AVX512BW
VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.WIG 00 /r	AVX512VL AVX512BW
VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.WIG 00 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshufbitqmb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshufbitqmb<T, U, V>, 

VPSHUFBITQMB instruction

Instruction	Opcode	CPUID
VPSHUFBITQMB k1 {k2}, xmm2, xmm3/m128	EVEX.128.66.0F38.W0 8F /r	AVX512VL AVX512_BITALG
VPSHUFBITQMB k1 {k2}, ymm2, ymm3/m256	EVEX.256.66.0F38.W0 8F /r	AVX512VL AVX512_BITALG
VPSHUFBITQMB k1 {k2}, zmm2, zmm3/m512	EVEX.512.66.0F38.W0 8F /r	AVX512_BITALG

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshufd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshufd<T, U, V>, 

VPSHUFD instruction

Instruction	Opcode	CPUID
VPSHUFD xmm1, xmm2/m128, imm8	VEX.128.66.0F.WIG 70 /r ib	AVX
VPSHUFD ymm1, ymm2/m256, imm8	VEX.256.66.0F.WIG 70 /r ib	AVX2
VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F.W0 70 /r ib	AVX512VL AVX512F
VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F.W0 70 /r ib	AVX512VL AVX512F
VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8	EVEX.512.66.0F.W0 70 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshufhw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshufhw<T, U, V>, 

VPSHUFHW instruction

Instruction	Opcode	CPUID
VPSHUFHW xmm1, xmm2/m128, imm8	VEX.128.F3.0F.WIG 70 /r ib	AVX
VPSHUFHW ymm1, ymm2/m256, imm8	VEX.256.F3.0F.WIG 70 /r ib	AVX2
VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8	EVEX.128.F3.0F.WIG 70 /r ib	AVX512VL AVX512BW
VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8	EVEX.256.F3.0F.WIG 70 /r ib	AVX512VL AVX512BW
VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8	EVEX.512.F3.0F.WIG 70 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpshuflw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpshuflw<T, U, V>, 

VPSHUFLW instruction

Instruction	Opcode	CPUID
VPSHUFLW xmm1, xmm2/m128, imm8	VEX.128.F2.0F.WIG 70 /r ib	AVX
VPSHUFLW ymm1, ymm2/m256, imm8	VEX.256.F2.0F.WIG 70 /r ib	AVX2
VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8	EVEX.128.F2.0F.WIG 70 /r ib	AVX512VL AVX512BW
VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8	EVEX.256.F2.0F.WIG 70 /r ib	AVX512VL AVX512BW
VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8	EVEX.512.F2.0F.WIG 70 /r ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsignb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsignb<T, U, V>, 

VPSIGNB instruction

Instruction	Opcode	CPUID
VPSIGNB xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 08 /r	AVX
VPSIGNB ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 08 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsignd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsignd<T, U, V>, 

VPSIGND instruction

Instruction	Opcode	CPUID
VPSIGND xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 0A /r	AVX
VPSIGND ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 0A /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsignw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsignw<T, U, V>, 

VPSIGNW instruction

Instruction	Opcode	CPUID
VPSIGNW xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.WIG 09 /r	AVX
VPSIGNW ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.WIG 09 /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpslld<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpslld<T, U, V>, 

VPSLLD instruction

Instruction	Opcode	CPUID
VPSLLD xmm1, xmm2, imm8	VEX.128.66.0F.WIG 72 /6 ib	AVX
VPSLLD ymm1, ymm2, imm8	VEX.256.66.0F.WIG 72 /6 ib	AVX2
VPSLLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F.W0 72 /6 ib	AVX512VL AVX512F
VPSLLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F.W0 72 /6 ib	AVX512VL AVX512F
VPSLLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8	EVEX.512.66.0F.W0 72 /6 ib	AVX512F
VPSLLD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG F2 /r	AVX
VPSLLD ymm1, ymm2, xmm3/m128	VEX.256.66.0F.WIG F2 /r	AVX2
VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.W0 F2 /r	AVX512VL AVX512F
VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128	EVEX.256.66.0F.W0 F2 /r	AVX512VL AVX512F
VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128	EVEX.512.66.0F.W0 F2 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpslldq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpslldq<T, U, V>, 

VPSLLDQ instruction

Instruction	Opcode	CPUID
VPSLLDQ xmm1, xmm2, imm8	VEX.128.66.0F.WIG 73 /7 ib	AVX
VPSLLDQ ymm1, ymm2, imm8	VEX.256.66.0F.WIG 73 /7 ib	AVX2
VPSLLDQ xmm1, xmm2/m128, imm8	EVEX.128.66.0F.WIG 73 /7 ib	AVX512VL AVX512BW
VPSLLDQ ymm1, ymm2/m256, imm8	EVEX.256.66.0F.WIG 73 /7 ib	AVX512VL AVX512BW
VPSLLDQ zmm1, zmm2/m512, imm8	EVEX.512.66.0F.WIG 73 /7 ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsllq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsllq<T, U, V>, 

VPSLLQ instruction

Instruction	Opcode	CPUID
VPSLLQ xmm1, xmm2, imm8	VEX.128.66.0F.WIG 73 /6 ib	AVX
VPSLLQ ymm1, ymm2, imm8	VEX.256.66.0F.WIG 73 /6 ib	AVX2
VPSLLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F.W1 73 /6 ib	AVX512VL AVX512F
VPSLLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F.W1 73 /6 ib	AVX512VL AVX512F
VPSLLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F.W1 73 /6 ib	AVX512F
VPSLLQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG F3 /r	AVX
VPSLLQ ymm1, ymm2, xmm3/m128	VEX.256.66.0F.WIG F3 /r	AVX2
VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.W1 F3 /r	AVX512VL AVX512F
VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128	EVEX.256.66.0F.W1 F3 /r	AVX512VL AVX512F
VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128	EVEX.512.66.0F.W1 F3 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsllvd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsllvd<T, U, V>, 

VPSLLVD instruction

Instruction	Opcode	CPUID
VPSLLVD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 47 /r	AVX2
VPSLLVD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 47 /r	AVX2
VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 47 /r	AVX512VL AVX512F
VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 47 /r	AVX512VL AVX512F
VPSLLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 47 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsllvq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsllvq<T, U, V>, 

VPSLLVQ instruction

Instruction	Opcode	CPUID
VPSLLVQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 47 /r	AVX2
VPSLLVQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 47 /r	AVX2
VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 47 /r	AVX512VL AVX512F
VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 47 /r	AVX512VL AVX512F
VPSLLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 47 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsllvw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsllvw<T, U, V>, 

VPSLLVW instruction

Instruction	Opcode	CPUID
VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 12 /r	AVX512VL AVX512BW
VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 12 /r	AVX512VL AVX512BW
VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 12 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsllw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsllw<T, U, V>, 

VPSLLW instruction

Instruction	Opcode	CPUID
VPSLLW xmm1, xmm2, imm8	VEX.128.66.0F.WIG 71 /6 ib	AVX
VPSLLW ymm1, ymm2, imm8	VEX.256.66.0F.WIG 71 /6 ib	AVX2
VPSLLW xmm1 {k1}{z}, xmm2/m128, imm8	EVEX.128.66.0F.WIG 71 /6 ib	AVX512VL AVX512BW
VPSLLW ymm1 {k1}{z}, ymm2/m256, imm8	EVEX.256.66.0F.WIG 71 /6 ib	AVX512VL AVX512BW
VPSLLW zmm1 {k1}{z}, zmm2/m512, imm8	EVEX.512.66.0F.WIG 71 /6 ib	AVX512BW
VPSLLW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG F1 /r	AVX
VPSLLW ymm1, ymm2, xmm3/m128	VEX.256.66.0F.WIG F1 /r	AVX2
VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG F1 /r	AVX512VL AVX512BW
VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128	EVEX.256.66.0F.WIG F1 /r	AVX512VL AVX512BW
VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128	EVEX.512.66.0F.WIG F1 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsrad<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsrad<T, U, V>, 

VPSRAD instruction

Instruction	Opcode	CPUID
VPSRAD xmm1, xmm2, imm8	VEX.128.66.0F.WIG 72 /4 ib	AVX
VPSRAD ymm1, ymm2, imm8	VEX.256.66.0F.WIG 72 /4 ib	AVX2
VPSRAD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F.W0 72 /4 ib	AVX512VL AVX512F
VPSRAD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F.W0 72 /4 ib	AVX512VL AVX512F
VPSRAD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8	EVEX.512.66.0F.W0 72 /4 ib	AVX512F
VPSRAD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG E2 /r	AVX
VPSRAD ymm1, ymm2, xmm3/m128	VEX.256.66.0F.WIG E2 /r	AVX2
VPSRAD xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.W0 E2 /r	AVX512VL AVX512F
VPSRAD ymm1 {k1}{z}, ymm2, xmm3/m128	EVEX.256.66.0F.W0 E2 /r	AVX512VL AVX512F
VPSRAD zmm1 {k1}{z}, zmm2, xmm3/m128	EVEX.512.66.0F.W0 E2 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsraq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsraq<T, U, V>, 

VPSRAQ instruction

Instruction	Opcode	CPUID
VPSRAQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F.W1 72 /4 ib	AVX512VL AVX512F
VPSRAQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F.W1 72 /4 ib	AVX512VL AVX512F
VPSRAQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F.W1 72 /4 ib	AVX512F
VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.W1 E2 /r	AVX512VL AVX512F
VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128	EVEX.256.66.0F.W1 E2 /r	AVX512VL AVX512F
VPSRAQ zmm1 {k1}{z}, zmm2, xmm3/m128	EVEX.512.66.0F.W1 E2 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsravd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsravd<T, U, V>, 

VPSRAVD instruction

Instruction	Opcode	CPUID
VPSRAVD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 46 /r	AVX2
VPSRAVD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 46 /r	AVX2
VPSRAVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 46 /r	AVX512VL AVX512F
VPSRAVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 46 /r	AVX512VL AVX512F
VPSRAVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 46 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsravq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsravq<T, U, V>, 

VPSRAVQ instruction

Instruction	Opcode	CPUID
VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 46 /r	AVX512VL AVX512F
VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 46 /r	AVX512VL AVX512F
VPSRAVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 46 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsravw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsravw<T, U, V>, 

VPSRAVW instruction

Instruction	Opcode	CPUID
VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 11 /r	AVX512VL AVX512BW
VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 11 /r	AVX512VL AVX512BW
VPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 11 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsraw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsraw<T, U, V>, 

VPSRAW instruction

Instruction	Opcode	CPUID
VPSRAW xmm1, xmm2, imm8	VEX.128.66.0F.WIG 71 /4 ib	AVX
VPSRAW ymm1, ymm2, imm8	VEX.256.66.0F.WIG 71 /4 ib	AVX2
VPSRAW xmm1 {k1}{z}, xmm2/m128, imm8	EVEX.128.66.0F.WIG 71 /4 ib	AVX512VL AVX512BW
VPSRAW ymm1 {k1}{z}, ymm2/m256, imm8	EVEX.256.66.0F.WIG 71 /4 ib	AVX512VL AVX512BW
VPSRAW zmm1 {k1}{z}, zmm2/m512, imm8	EVEX.512.66.0F.WIG 71 /4 ib	AVX512BW
VPSRAW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG E1 /r	AVX
VPSRAW ymm1, ymm2, xmm3/m128	VEX.256.66.0F.WIG E1 /r	AVX2
VPSRAW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG E1 /r	AVX512VL AVX512BW
VPSRAW ymm1 {k1}{z}, ymm2, xmm3/m128	EVEX.256.66.0F.WIG E1 /r	AVX512VL AVX512BW
VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128	EVEX.512.66.0F.WIG E1 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsrld<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsrld<T, U, V>, 

VPSRLD instruction

Instruction	Opcode	CPUID
VPSRLD xmm1, xmm2, imm8	VEX.128.66.0F.WIG 72 /2 ib	AVX
VPSRLD ymm1, ymm2, imm8	VEX.256.66.0F.WIG 72 /2 ib	AVX2
VPSRLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F.W0 72 /2 ib	AVX512VL AVX512F
VPSRLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F.W0 72 /2 ib	AVX512VL AVX512F
VPSRLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8	EVEX.512.66.0F.W0 72 /2 ib	AVX512F
VPSRLD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG D2 /r	AVX
VPSRLD ymm1, ymm2, xmm3/m128	VEX.256.66.0F.WIG D2 /r	AVX2
VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.W0 D2 /r	AVX512VL AVX512F
VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128	EVEX.256.66.0F.W0 D2 /r	AVX512VL AVX512F
VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128	EVEX.512.66.0F.W0 D2 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsrldq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsrldq<T, U, V>, 

VPSRLDQ instruction

Instruction	Opcode	CPUID
VPSRLDQ xmm1, xmm2, imm8	VEX.128.66.0F.WIG 73 /3 ib	AVX
VPSRLDQ ymm1, ymm2, imm8	VEX.256.66.0F.WIG 73 /3 ib	AVX2
VPSRLDQ xmm1, xmm2/m128, imm8	EVEX.128.66.0F.WIG 73 /3 ib	AVX512VL AVX512BW
VPSRLDQ ymm1, ymm2/m256, imm8	EVEX.256.66.0F.WIG 73 /3 ib	AVX512VL AVX512BW
VPSRLDQ zmm1, zmm2/m512, imm8	EVEX.512.66.0F.WIG 73 /3 ib	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsrlq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsrlq<T, U, V>, 

VPSRLQ instruction

Instruction	Opcode	CPUID
VPSRLQ xmm1, xmm2, imm8	VEX.128.66.0F.WIG 73 /2 ib	AVX
VPSRLQ ymm1, ymm2, imm8	VEX.256.66.0F.WIG 73 /2 ib	AVX2
VPSRLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F.W1 73 /2 ib	AVX512VL AVX512F
VPSRLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F.W1 73 /2 ib	AVX512VL AVX512F
VPSRLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8	EVEX.512.66.0F.W1 73 /2 ib	AVX512F
VPSRLQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG D3 /r	AVX
VPSRLQ ymm1, ymm2, xmm3/m128	VEX.256.66.0F.WIG D3 /r	AVX2
VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.W1 D3 /r	AVX512VL AVX512F
VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128	EVEX.256.66.0F.W1 D3 /r	AVX512VL AVX512F
VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128	EVEX.512.66.0F.W1 D3 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsrlvd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsrlvd<T, U, V>, 

VPSRLVD instruction

Instruction	Opcode	CPUID
VPSRLVD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 45 /r	AVX2
VPSRLVD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 45 /r	AVX2
VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 45 /r	AVX512VL AVX512F
VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 45 /r	AVX512VL AVX512F
VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 45 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsrlvq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsrlvq<T, U, V>, 

VPSRLVQ instruction

Instruction	Opcode	CPUID
VPSRLVQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W1 45 /r	AVX2
VPSRLVQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 45 /r	AVX2
VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 45 /r	AVX512VL AVX512F
VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 45 /r	AVX512VL AVX512F
VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 45 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsrlvw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsrlvw<T, U, V>, 

VPSRLVW instruction

Instruction	Opcode	CPUID
VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 10 /r	AVX512VL AVX512BW
VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 10 /r	AVX512VL AVX512BW
VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 10 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsrlw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsrlw<T, U, V>, 

VPSRLW instruction

Instruction	Opcode	CPUID
VPSRLW xmm1, xmm2, imm8	VEX.128.66.0F.WIG 71 /2 ib	AVX
VPSRLW ymm1, ymm2, imm8	VEX.256.66.0F.WIG 71 /2 ib	AVX2
VPSRLW xmm1 {k1}{z}, xmm2/m128, imm8	EVEX.128.66.0F.WIG 71 /2 ib	AVX512VL AVX512BW
VPSRLW ymm1 {k1}{z}, ymm2/m256, imm8	EVEX.256.66.0F.WIG 71 /2 ib	AVX512VL AVX512BW
VPSRLW zmm1 {k1}{z}, zmm2/m512, imm8	EVEX.512.66.0F.WIG 71 /2 ib	AVX512BW
VPSRLW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG D1 /r	AVX
VPSRLW ymm1, ymm2, xmm3/m128	VEX.256.66.0F.WIG D1 /r	AVX2
VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG D1 /r	AVX512VL AVX512BW
VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128	EVEX.256.66.0F.WIG D1 /r	AVX512VL AVX512BW
VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128	EVEX.512.66.0F.WIG D1 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsubb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsubb<T, U, V>, 

VPSUBB instruction

Instruction	Opcode	CPUID
VPSUBB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG F8 /r	AVX
VPSUBB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG F8 /r	AVX2
VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG F8 /r	AVX512VL AVX512BW
VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG F8 /r	AVX512VL AVX512BW
VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG F8 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsubd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsubd<T, U, V>, 

VPSUBD instruction

Instruction	Opcode	CPUID
VPSUBD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG FA /r	AVX
VPSUBD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG FA /r	AVX2
VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 FA /r	AVX512VL AVX512F
VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 FA /r	AVX512VL AVX512F
VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 FA /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsubq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsubq<T, U, V>, 

VPSUBQ instruction

Instruction	Opcode	CPUID
VPSUBQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG FB /r	AVX
VPSUBQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG FB /r	AVX2
VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 FB /r	AVX512VL AVX512F
VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 FB /r	AVX512VL AVX512F
VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 FB /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsubsb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsubsb<T, U, V>, 

VPSUBSB instruction

Instruction	Opcode	CPUID
VPSUBSB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG E8 /r	AVX
VPSUBSB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG E8 /r	AVX2
VPSUBSB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG E8 /r	AVX512VL AVX512BW
VPSUBSB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG E8 /r	AVX512VL AVX512BW
VPSUBSB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG E8 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsubsw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsubsw<T, U, V>, 

VPSUBSW instruction

Instruction	Opcode	CPUID
VPSUBSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG E9 /r	AVX
VPSUBSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG E9 /r	AVX2
VPSUBSW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG E9 /r	AVX512VL AVX512BW
VPSUBSW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG E9 /r	AVX512VL AVX512BW
VPSUBSW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG E9 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsubusb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsubusb<T, U, V>, 

VPSUBUSB instruction

Instruction	Opcode	CPUID
VPSUBUSB xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG D8 /r	AVX
VPSUBUSB ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG D8 /r	AVX2
VPSUBUSB xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG D8 /r	AVX512VL AVX512BW
VPSUBUSB ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG D8 /r	AVX512VL AVX512BW
VPSUBUSB zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG D8 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsubusw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsubusw<T, U, V>, 

VPSUBUSW instruction

Instruction	Opcode	CPUID
VPSUBUSW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG D9 /r	AVX
VPSUBUSW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG D9 /r	AVX2
VPSUBUSW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG D9 /r	AVX512VL AVX512BW
VPSUBUSW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG D9 /r	AVX512VL AVX512BW
VPSUBUSW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG D9 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpsubw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpsubw<T, U, V>, 

VPSUBW instruction

Instruction	Opcode	CPUID
VPSUBW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG F9 /r	AVX
VPSUBW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG F9 /r	AVX2
VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG F9 /r	AVX512VL AVX512BW
VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG F9 /r	AVX512VL AVX512BW
VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG F9 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpternlogd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpternlogd<T, U, V, W>, 

VPTERNLOGD instruction

Instruction	Opcode	CPUID
VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 25 /r ib	AVX512VL AVX512F
VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 25 /r ib	AVX512VL AVX512F
VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 25 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vpternlogq<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVpternlogq<T, U, V, W>, 

VPTERNLOGQ instruction

Instruction	Opcode	CPUID
VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 25 /r ib	AVX512VL AVX512F
VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 25 /r ib	AVX512VL AVX512F
VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 25 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vptest<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVptest<T, U>, 

VPTEST instruction

Instruction	Opcode	CPUID
VPTEST xmm1, xmm2/m128	VEX.128.66.0F38.WIG 17 /r	AVX
VPTEST ymm1, ymm2/m256	VEX.256.66.0F38.WIG 17 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vptestmb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVptestmb<T, U, V>, 

VPTESTMB instruction

Instruction	Opcode	CPUID
VPTESTMB k2 {k1}, xmm2, xmm3/m128	EVEX.128.66.0F38.W0 26 /r	AVX512VL AVX512BW
VPTESTMB k2 {k1}, ymm2, ymm3/m256	EVEX.256.66.0F38.W0 26 /r	AVX512VL AVX512BW
VPTESTMB k2 {k1}, zmm2, zmm3/m512	EVEX.512.66.0F38.W0 26 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vptestmd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVptestmd<T, U, V>, 

VPTESTMD instruction

Instruction	Opcode	CPUID
VPTESTMD k2 {k1}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 27 /r	AVX512VL AVX512F
VPTESTMD k2 {k1}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 27 /r	AVX512VL AVX512F
VPTESTMD k2 {k1}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F38.W0 27 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vptestmq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVptestmq<T, U, V>, 

VPTESTMQ instruction

Instruction	Opcode	CPUID
VPTESTMQ k2 {k1}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 27 /r	AVX512VL AVX512F
VPTESTMQ k2 {k1}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 27 /r	AVX512VL AVX512F
VPTESTMQ k2 {k1}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F38.W1 27 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vptestmw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVptestmw<T, U, V>, 

VPTESTMW instruction

Instruction	Opcode	CPUID
VPTESTMW k2 {k1}, xmm2, xmm3/m128	EVEX.128.66.0F38.W1 26 /r	AVX512VL AVX512BW
VPTESTMW k2 {k1}, ymm2, ymm3/m256	EVEX.256.66.0F38.W1 26 /r	AVX512VL AVX512BW
VPTESTMW k2 {k1}, zmm2, zmm3/m512	EVEX.512.66.0F38.W1 26 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vptestnmb<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVptestnmb<T, U, V>, 

VPTESTNMB instruction

Instruction	Opcode	CPUID
VPTESTNMB k2 {k1}, xmm2, xmm3/m128	EVEX.128.F3.0F38.W0 26 /r	AVX512VL AVX512BW
VPTESTNMB k2 {k1}, ymm2, ymm3/m256	EVEX.256.F3.0F38.W0 26 /r	AVX512VL AVX512BW
VPTESTNMB k2 {k1}, zmm2, zmm3/m512	EVEX.512.F3.0F38.W0 26 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vptestnmd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVptestnmd<T, U, V>, 

VPTESTNMD instruction

Instruction	Opcode	CPUID
VPTESTNMD k2 {k1}, xmm2, xmm3/m128/m32bcst	EVEX.128.F3.0F38.W0 27 /r	AVX512VL AVX512F
VPTESTNMD k2 {k1}, ymm2, ymm3/m256/m32bcst	EVEX.256.F3.0F38.W0 27 /r	AVX512VL AVX512F
VPTESTNMD k2 {k1}, zmm2, zmm3/m512/m32bcst	EVEX.512.F3.0F38.W0 27 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vptestnmq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVptestnmq<T, U, V>, 

VPTESTNMQ instruction

Instruction	Opcode	CPUID
VPTESTNMQ k2 {k1}, xmm2, xmm3/m128/m64bcst	EVEX.128.F3.0F38.W1 27 /r	AVX512VL AVX512F
VPTESTNMQ k2 {k1}, ymm2, ymm3/m256/m64bcst	EVEX.256.F3.0F38.W1 27 /r	AVX512VL AVX512F
VPTESTNMQ k2 {k1}, zmm2, zmm3/m512/m64bcst	EVEX.512.F3.0F38.W1 27 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vptestnmw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVptestnmw<T, U, V>, 

VPTESTNMW instruction

Instruction	Opcode	CPUID
VPTESTNMW k2 {k1}, xmm2, xmm3/m128	EVEX.128.F3.0F38.W1 26 /r	AVX512VL AVX512BW
VPTESTNMW k2 {k1}, ymm2, ymm3/m256	EVEX.256.F3.0F38.W1 26 /r	AVX512VL AVX512BW
VPTESTNMW k2 {k1}, zmm2, zmm3/m512	EVEX.512.F3.0F38.W1 26 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpunpckhbw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpunpckhbw<T, U, V>, 

VPUNPCKHBW instruction

Instruction	Opcode	CPUID
VPUNPCKHBW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 68 /r	AVX
VPUNPCKHBW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 68 /r	AVX2
VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 68 /r	AVX512VL AVX512BW
VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 68 /r	AVX512VL AVX512BW
VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 68 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpunpckhdq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpunpckhdq<T, U, V>, 

VPUNPCKHDQ instruction

Instruction	Opcode	CPUID
VPUNPCKHDQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 6A /r	AVX
VPUNPCKHDQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 6A /r	AVX2
VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 6A /r	AVX512VL AVX512F
VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 6A /r	AVX512VL AVX512F
VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 6A /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpunpckhqdq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpunpckhqdq<T, U, V>, 

VPUNPCKHQDQ instruction

Instruction	Opcode	CPUID
VPUNPCKHQDQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 6D /r	AVX
VPUNPCKHQDQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 6D /r	AVX2
VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 6D /r	AVX512VL AVX512F
VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 6D /r	AVX512VL AVX512F
VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 6D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpunpckhwd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpunpckhwd<T, U, V>, 

VPUNPCKHWD instruction

Instruction	Opcode	CPUID
VPUNPCKHWD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 69 /r	AVX
VPUNPCKHWD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 69 /r	AVX2
VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 69 /r	AVX512VL AVX512BW
VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 69 /r	AVX512VL AVX512BW
VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 69 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpunpcklbw<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpunpcklbw<T, U, V>, 

VPUNPCKLBW instruction

Instruction	Opcode	CPUID
VPUNPCKLBW xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 60 /r	AVX
VPUNPCKLBW ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 60 /r	AVX2
VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 60 /r	AVX512VL AVX512BW
VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 60 /r	AVX512VL AVX512BW
VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 60 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpunpckldq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpunpckldq<T, U, V>, 

VPUNPCKLDQ instruction

Instruction	Opcode	CPUID
VPUNPCKLDQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 62 /r	AVX
VPUNPCKLDQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 62 /r	AVX2
VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 62 /r	AVX512VL AVX512F
VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 62 /r	AVX512VL AVX512F
VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 62 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpunpcklqdq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpunpcklqdq<T, U, V>, 

VPUNPCKLQDQ instruction

Instruction	Opcode	CPUID
VPUNPCKLQDQ xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 6C /r	AVX
VPUNPCKLQDQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 6C /r	AVX2
VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 6C /r	AVX512VL AVX512F
VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 6C /r	AVX512VL AVX512F
VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 6C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpunpcklwd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpunpcklwd<T, U, V>, 

VPUNPCKLWD instruction

Instruction	Opcode	CPUID
VPUNPCKLWD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 61 /r	AVX
VPUNPCKLWD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 61 /r	AVX2
VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128	EVEX.128.66.0F.WIG 61 /r	AVX512VL AVX512BW
VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256	EVEX.256.66.0F.WIG 61 /r	AVX512VL AVX512BW
VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512	EVEX.512.66.0F.WIG 61 /r	AVX512BW

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpxor<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpxor<T, U, V>, 

VPXOR instruction

Instruction	Opcode	CPUID
VPXOR xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG EF /r	AVX
VPXOR ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG EF /r	AVX2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpxord<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpxord<T, U, V>, 

VPXORD instruction

Instruction	Opcode	CPUID
VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F.W0 EF /r	AVX512VL AVX512F
VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F.W0 EF /r	AVX512VL AVX512F
VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.66.0F.W0 EF /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vpxorq<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVpxorq<T, U, V>, 

VPXORQ instruction

Instruction	Opcode	CPUID
VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 EF /r	AVX512VL AVX512F
VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 EF /r	AVX512VL AVX512F
VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 EF /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrangepd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVrangepd<T, U, V, W>, 

VRANGEPD instruction

Instruction	Opcode	CPUID
VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 50 /r ib	AVX512VL AVX512DQ
VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 50 /r ib	AVX512VL AVX512DQ
VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8	EVEX.512.66.0F3A.W1 50 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vrangeps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVrangeps<T, U, V, W>, 

VRANGEPS instruction

Instruction	Opcode	CPUID
VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 50 /r ib	AVX512VL AVX512DQ
VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 50 /r ib	AVX512VL AVX512DQ
VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8	EVEX.512.66.0F3A.W0 50 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vrangesd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVrangesd<T, U, V, W>, 

VRANGESD instruction

Instruction	Opcode	CPUID
VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.66.0F3A.W1 51 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vrangess<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVrangess<T, U, V, W>, 

VRANGESS instruction

Instruction	Opcode	CPUID
VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.66.0F3A.W0 51 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vrcp14pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrcp14pd<T, U>, 

VRCP14PD instruction

Instruction	Opcode	CPUID
VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F38.W1 4C /r	AVX512VL AVX512F
VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F38.W1 4C /r	AVX512VL AVX512F
VRCP14PD zmm1 {k1}{z}, zmm2/m512/m64bcst	EVEX.512.66.0F38.W1 4C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrcp14ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrcp14ps<T, U>, 

VRCP14PS instruction

Instruction	Opcode	CPUID
VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.0F38.W0 4C /r	AVX512VL AVX512F
VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.0F38.W0 4C /r	AVX512VL AVX512F
VRCP14PS zmm1 {k1}{z}, zmm2/m512/m32bcst	EVEX.512.66.0F38.W0 4C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrcp14sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrcp14sd<T, U, V>, 

VRCP14SD instruction

Instruction	Opcode	CPUID
VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64	EVEX.LIG.66.0F38.W1 4D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrcp14ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrcp14ss<T, U, V>, 

VRCP14SS instruction

Instruction	Opcode	CPUID
VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32	EVEX.LIG.66.0F38.W0 4D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrcp28pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrcp28pd<T, U>, 

VRCP28PD instruction

Instruction	Opcode	CPUID
VRCP28PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}	EVEX.512.66.0F38.W1 CA /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrcp28ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrcp28ps<T, U>, 

VRCP28PS instruction

Instruction	Opcode	CPUID
VRCP28PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}	EVEX.512.66.0F38.W0 CA /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrcp28sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrcp28sd<T, U, V>, 

VRCP28SD instruction

Instruction	Opcode	CPUID
VRCP28SD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}	EVEX.LIG.66.0F38.W1 CB /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrcp28ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrcp28ss<T, U, V>, 

VRCP28SS instruction

Instruction	Opcode	CPUID
VRCP28SS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}	EVEX.LIG.66.0F38.W0 CB /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrcpph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrcpph<T, U>, 

VRCPPH instruction

Instruction	Opcode	CPUID
VRCPPH xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.66.MAP6.W0 4C /r	AVX512VL AVX512-FP16
VRCPPH ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.66.MAP6.W0 4C /r	AVX512VL AVX512-FP16
VRCPPH zmm1 {k1}{z}, zmm2/m512/m16bcst	EVEX.512.66.MAP6.W0 4C /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrcpps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrcpps<T, U>, 

VRCPPS instruction

Instruction	Opcode	CPUID
VRCPPS xmm1, xmm2/m128	VEX.128.0F.WIG 53 /r	AVX
VRCPPS ymm1, ymm2/m256	VEX.256.0F.WIG 53 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrcpsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrcpsh<T, U, V>, 

VRCPSH instruction

Instruction	Opcode	CPUID
VRCPSH xmm1 {k1}{z}, xmm2, xmm3/m16	EVEX.LIG.66.MAP6.W0 4D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrcpss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrcpss<T, U, V>, 

VRCPSS instruction

Instruction	Opcode	CPUID
VRCPSS xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 53 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vreducepd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVreducepd<T, U, V>, 

VREDUCEPD instruction

Instruction	Opcode	CPUID
VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 56 /r ib	AVX512VL AVX512DQ
VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 56 /r ib	AVX512VL AVX512DQ
VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8	EVEX.512.66.0F3A.W1 56 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vreduceph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVreduceph<T, U, V>, 

VREDUCEPH instruction

Instruction	Opcode	CPUID
VREDUCEPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8	EVEX.128.0F3A.W0 56 /r ib	AVX512VL AVX512-FP16
VREDUCEPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8	EVEX.256.0F3A.W0 56 /r ib	AVX512VL AVX512-FP16
VREDUCEPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 56 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vreduceps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVreduceps<T, U, V>, 

VREDUCEPS instruction

Instruction	Opcode	CPUID
VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 56 /r ib	AVX512VL AVX512DQ
VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 56 /r ib	AVX512VL AVX512DQ
VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8	EVEX.512.66.0F3A.W0 56 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vreducesd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVreducesd<T, U, V, W>, 

VREDUCESD instruction

Instruction	Opcode	CPUID
VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.66.0F3A.W1 57 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vreducesh<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVreducesh<T, U, V, W>, 

VREDUCESH instruction

Instruction	Opcode	CPUID
VREDUCESH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.0F3A.W0 57 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vreducess<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVreducess<T, U, V, W>, 

VREDUCESS instruction

Instruction	Opcode	CPUID
VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.66.0F3A.W0 57 /r ib	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vrndscalepd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrndscalepd<T, U, V>, 

VRNDSCALEPD instruction

Instruction	Opcode	CPUID
VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8	EVEX.128.66.0F3A.W1 09 /r ib	AVX512VL AVX512F
VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 09 /r ib	AVX512VL AVX512F
VRNDSCALEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8	EVEX.512.66.0F3A.W1 09 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrndscaleph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrndscaleph<T, U, V>, 

VRNDSCALEPH instruction

Instruction	Opcode	CPUID
VRNDSCALEPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8	EVEX.128.0F3A.W0 08 /r ib	AVX512VL AVX512-FP16
VRNDSCALEPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8	EVEX.256.0F3A.W0 08 /r ib	AVX512VL AVX512-FP16
VRNDSCALEPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8	EVEX.512.0F3A.W0 08 /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrndscaleps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrndscaleps<T, U, V>, 

VRNDSCALEPS instruction

Instruction	Opcode	CPUID
VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8	EVEX.128.66.0F3A.W0 08 /r ib	AVX512VL AVX512F
VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 08 /r ib	AVX512VL AVX512F
VRNDSCALEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8	EVEX.512.66.0F3A.W0 08 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrndscalesd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVrndscalesd<T, U, V, W>, 

VRNDSCALESD instruction

Instruction	Opcode	CPUID
VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8	EVEX.LIG.66.0F3A.W1 0B /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vrndscalesh<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVrndscalesh<T, U, V, W>, 

VRNDSCALESH instruction

Instruction	Opcode	CPUID
VRNDSCALESH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8	EVEX.LIG.0F3A.W0 0A /r ib	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vrndscaless<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVrndscaless<T, U, V, W>, 

VRNDSCALESS instruction

Instruction	Opcode	CPUID
VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8	EVEX.LIG.66.0F3A.W0 0A /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vroundpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVroundpd<T, U, V>, 

VROUNDPD instruction

Instruction	Opcode	CPUID
VROUNDPD xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.WIG 09 /r ib	AVX
VROUNDPD ymm1, ymm2/m256, imm8	VEX.256.66.0F3A.WIG 09 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vroundps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVroundps<T, U, V>, 

VROUNDPS instruction

Instruction	Opcode	CPUID
VROUNDPS xmm1, xmm2/m128, imm8	VEX.128.66.0F3A.WIG 08 /r ib	AVX
VROUNDPS ymm1, ymm2/m256, imm8	VEX.256.66.0F3A.WIG 08 /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vroundsd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVroundsd<T, U, V, W>, 

VROUNDSD instruction

Instruction	Opcode	CPUID
VROUNDSD xmm1, xmm2, xmm3/m64, imm8	VEX.LIG.66.0F3A.WIG 0B /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vroundss<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVroundss<T, U, V, W>, 

VROUNDSS instruction

Instruction	Opcode	CPUID
VROUNDSS xmm1, xmm2, xmm3/m32, imm8	VEX.LIG.66.0F3A.WIG 0A /r ib	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vrsqrt14pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrt14pd<T, U>, 

VRSQRT14PD instruction

Instruction	Opcode	CPUID
VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F38.W1 4E /r	AVX512VL AVX512F
VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F38.W1 4E /r	AVX512VL AVX512F
VRSQRT14PD zmm1 {k1}{z}, zmm2/m512/m64bcst	EVEX.512.66.0F38.W1 4E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrsqrt14ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrt14ps<T, U>, 

VRSQRT14PS instruction

Instruction	Opcode	CPUID
VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.66.0F38.W0 4E /r	AVX512VL AVX512F
VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.66.0F38.W0 4E /r	AVX512VL AVX512F
VRSQRT14PS zmm1 {k1}{z}, zmm2/m512/m32bcst	EVEX.512.66.0F38.W0 4E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrsqrt14sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrt14sd<T, U, V>, 

VRSQRT14SD instruction

Instruction	Opcode	CPUID
VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64	EVEX.LIG.66.0F38.W1 4F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrsqrt14ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrt14ss<T, U, V>, 

VRSQRT14SS instruction

Instruction	Opcode	CPUID
VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32	EVEX.LIG.66.0F38.W0 4F /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrsqrt28pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrt28pd<T, U>, 

VRSQRT28PD instruction

Instruction	Opcode	CPUID
VRSQRT28PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}	EVEX.512.66.0F38.W1 CC /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrsqrt28ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrt28ps<T, U>, 

VRSQRT28PS instruction

Instruction	Opcode	CPUID
VRSQRT28PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}	EVEX.512.66.0F38.W0 CC /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrsqrt28sd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrt28sd<T, U, V>, 

VRSQRT28SD instruction

Instruction	Opcode	CPUID
VRSQRT28SD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}	EVEX.LIG.66.0F38.W1 CD /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrsqrt28ss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrt28ss<T, U, V>, 

VRSQRT28SS instruction

Instruction	Opcode	CPUID
VRSQRT28SS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}	EVEX.LIG.66.0F38.W0 CD /r	AVX512ER

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrsqrtph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrtph<T, U>, 

VRSQRTPH instruction

Instruction	Opcode	CPUID
VRSQRTPH xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.66.MAP6.W0 4E /r	AVX512VL AVX512-FP16
VRSQRTPH ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.66.MAP6.W0 4E /r	AVX512VL AVX512-FP16
VRSQRTPH zmm1 {k1}{z}, zmm2/m512/m16bcst	EVEX.512.66.MAP6.W0 4E /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrsqrtps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrtps<T, U>, 

VRSQRTPS instruction

Instruction	Opcode	CPUID
VRSQRTPS xmm1, xmm2/m128	VEX.128.0F.WIG 52 /r	AVX
VRSQRTPS ymm1, ymm2/m256	VEX.256.0F.WIG 52 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vrsqrtsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrtsh<T, U, V>, 

VRSQRTSH instruction

Instruction	Opcode	CPUID
VRSQRTSH xmm1 {k1}{z}, xmm2, xmm3/m16	EVEX.LIG.66.MAP6.W0 4F /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vrsqrtss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVrsqrtss<T, U, V>, 

VRSQRTSS instruction

Instruction	Opcode	CPUID
VRSQRTSS xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 52 /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vscalefpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVscalefpd<T, U, V>, 

VSCALEFPD instruction

Instruction	Opcode	CPUID
VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F38.W1 2C /r	AVX512VL AVX512F
VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F38.W1 2C /r	AVX512VL AVX512F
VSCALEFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F38.W1 2C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vscalefph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVscalefph<T, U, V>, 

VSCALEFPH instruction

Instruction	Opcode	CPUID
VSCALEFPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.66.MAP6.W0 2C /r	AVX512VL AVX512-FP16
VSCALEFPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.66.MAP6.W0 2C /r	AVX512VL AVX512-FP16
VSCALEFPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.66.MAP6.W0 2C /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vscalefps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVscalefps<T, U, V>, 

VSCALEFPS instruction

Instruction	Opcode	CPUID
VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.66.0F38.W0 2C /r	AVX512VL AVX512F
VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.66.0F38.W0 2C /r	AVX512VL AVX512F
VSCALEFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.66.0F38.W0 2C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vscalefsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVscalefsd<T, U, V>, 

VSCALEFSD instruction

Instruction	Opcode	CPUID
VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.66.0F38.W1 2D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vscalefsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVscalefsh<T, U, V>, 

VSCALEFSH instruction

Instruction	Opcode	CPUID
VSCALEFSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.66.MAP6.W0 2D /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vscalefss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVscalefss<T, U, V>, 

VSCALEFSS instruction

Instruction	Opcode	CPUID
VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.66.0F38.W0 2D /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vscatterdpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVscatterdpd<T, U>, 

VSCATTERDPD instruction

Instruction	Opcode	CPUID
VSCATTERDPD vm32x {k1}, xmm1	EVEX.128.66.0F38.W1 A2 /vsib	AVX512VL AVX512F
VSCATTERDPD vm32x {k1}, ymm1	EVEX.256.66.0F38.W1 A2 /vsib	AVX512VL AVX512F
VSCATTERDPD vm32y {k1}, zmm1	EVEX.512.66.0F38.W1 A2 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vscatterdps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVscatterdps<T, U>, 

VSCATTERDPS instruction

Instruction	Opcode	CPUID
VSCATTERDPS vm32x {k1}, xmm1	EVEX.128.66.0F38.W0 A2 /vsib	AVX512VL AVX512F
VSCATTERDPS vm32y {k1}, ymm1	EVEX.256.66.0F38.W0 A2 /vsib	AVX512VL AVX512F
VSCATTERDPS vm32z {k1}, zmm1	EVEX.512.66.0F38.W0 A2 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vscatterpf0dpd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVscatterpf0dpd<T>, 

VSCATTERPF0DPD instruction

Instruction	Opcode	CPUID
VSCATTERPF0DPD vm32y {k1}	EVEX.512.66.0F38.W1 C6 /5 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vscatterpf0dps<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVscatterpf0dps<T>, 

VSCATTERPF0DPS instruction

Instruction	Opcode	CPUID
VSCATTERPF0DPS vm32z {k1}	EVEX.512.66.0F38.W0 C6 /5 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vscatterpf0qpd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVscatterpf0qpd<T>, 

VSCATTERPF0QPD instruction

Instruction	Opcode	CPUID
VSCATTERPF0QPD vm64z {k1}	EVEX.512.66.0F38.W1 C7 /5 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vscatterpf0qps<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVscatterpf0qps<T>, 

VSCATTERPF0QPS instruction

Instruction	Opcode	CPUID
VSCATTERPF0QPS vm64z {k1}	EVEX.512.66.0F38.W0 C7 /5 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vscatterpf1dpd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVscatterpf1dpd<T>, 

VSCATTERPF1DPD instruction

Instruction	Opcode	CPUID
VSCATTERPF1DPD vm32y {k1}	EVEX.512.66.0F38.W1 C6 /6 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vscatterpf1dps<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVscatterpf1dps<T>, 

VSCATTERPF1DPS instruction

Instruction	Opcode	CPUID
VSCATTERPF1DPS vm32z {k1}	EVEX.512.66.0F38.W0 C6 /6 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vscatterpf1qpd<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVscatterpf1qpd<T>, 

VSCATTERPF1QPD instruction

Instruction	Opcode	CPUID
VSCATTERPF1QPD vm64z {k1}	EVEX.512.66.0F38.W1 C7 /6 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vscatterpf1qps<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVscatterpf1qps<T>, 

VSCATTERPF1QPS instruction

Instruction	Opcode	CPUID
VSCATTERPF1QPS vm64z {k1}	EVEX.512.66.0F38.W0 C7 /6 /vsib	AVX512PF

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vscatterqpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVscatterqpd<T, U>, 

VSCATTERQPD instruction

Instruction	Opcode	CPUID
VSCATTERQPD vm64x {k1}, xmm1	EVEX.128.66.0F38.W1 A3 /vsib	AVX512VL AVX512F
VSCATTERQPD vm64y {k1}, ymm1	EVEX.256.66.0F38.W1 A3 /vsib	AVX512VL AVX512F
VSCATTERQPD vm64z {k1}, zmm1	EVEX.512.66.0F38.W1 A3 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vscatterqps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVscatterqps<T, U>, 

VSCATTERQPS instruction

Instruction	Opcode	CPUID
VSCATTERQPS vm64x {k1}, xmm1	EVEX.128.66.0F38.W0 A3 /vsib	AVX512VL AVX512F
VSCATTERQPS vm64y {k1}, xmm1	EVEX.256.66.0F38.W0 A3 /vsib	AVX512VL AVX512F
VSCATTERQPS vm64z {k1}, ymm1	EVEX.512.66.0F38.W0 A3 /vsib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vshuff32x4<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVshuff32x4<T, U, V, W>, 

VSHUFF32X4 instruction

Instruction	Opcode	CPUID
VSHUFF32X4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 23 /r ib	AVX512VL AVX512F
VSHUFF32X4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 23 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vshuff64x2<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVshuff64x2<T, U, V, W>, 

VSHUFF64X2 instruction

Instruction	Opcode	CPUID
VSHUFF64X2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 23 /r ib	AVX512VL AVX512F
VSHUFF64X2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 23 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vshufi32x4<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVshufi32x4<T, U, V, W>, 

VSHUFI32X4 instruction

Instruction	Opcode	CPUID
VSHUFI32X4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.66.0F3A.W0 43 /r ib	AVX512VL AVX512F
VSHUFI32X4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.66.0F3A.W0 43 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vshufi64x2<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVshufi64x2<T, U, V, W>, 

VSHUFI64X2 instruction

Instruction	Opcode	CPUID
VSHUFI64X2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F3A.W1 43 /r ib	AVX512VL AVX512F
VSHUFI64X2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F3A.W1 43 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vshufpd<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVshufpd<T, U, V, W>, 

VSHUFPD instruction

Instruction	Opcode	CPUID
VSHUFPD xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F.WIG C6 /r ib	AVX
VSHUFPD ymm1, ymm2, ymm3/m256, imm8	VEX.256.66.0F.WIG C6 /r ib	AVX
VSHUFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8	EVEX.128.66.0F.W1 C6 /r ib	AVX512VL AVX512F
VSHUFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8	EVEX.256.66.0F.W1 C6 /r ib	AVX512VL AVX512F
VSHUFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8	EVEX.512.66.0F.W1 C6 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vshufps<T, U, V, W>(
    &mut self,
    op0: T,
    op1: U,
    op2: V,
    op3: W
) -> Result<(), IcedError> where
    Self: CodeAsmVshufps<T, U, V, W>, 

VSHUFPS instruction

Instruction	Opcode	CPUID
VSHUFPS xmm1, xmm2, xmm3/m128, imm8	VEX.128.0F.WIG C6 /r ib	AVX
VSHUFPS ymm1, ymm2, ymm3/m256, imm8	VEX.256.0F.WIG C6 /r ib	AVX
VSHUFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8	EVEX.128.0F.W0 C6 /r ib	AVX512VL AVX512F
VSHUFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8	EVEX.256.0F.W0 C6 /r ib	AVX512VL AVX512F
VSHUFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8	EVEX.512.0F.W0 C6 /r ib	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand
• op3: Fourth operand

pub fn vsqrtpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVsqrtpd<T, U>, 

VSQRTPD instruction

Instruction	Opcode	CPUID
VSQRTPD xmm1, xmm2/m128	VEX.128.66.0F.WIG 51 /r	AVX
VSQRTPD ymm1, ymm2/m256	VEX.256.66.0F.WIG 51 /r	AVX
VSQRTPD xmm1 {k1}{z}, xmm2/m128/m64bcst	EVEX.128.66.0F.W1 51 /r	AVX512VL AVX512F
VSQRTPD ymm1 {k1}{z}, ymm2/m256/m64bcst	EVEX.256.66.0F.W1 51 /r	AVX512VL AVX512F
VSQRTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}	EVEX.512.66.0F.W1 51 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vsqrtph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVsqrtph<T, U>, 

VSQRTPH instruction

Instruction	Opcode	CPUID
VSQRTPH xmm1 {k1}{z}, xmm2/m128/m16bcst	EVEX.128.MAP5.W0 51 /r	AVX512VL AVX512-FP16
VSQRTPH ymm1 {k1}{z}, ymm2/m256/m16bcst	EVEX.256.MAP5.W0 51 /r	AVX512VL AVX512-FP16
VSQRTPH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}	EVEX.512.MAP5.W0 51 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vsqrtps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVsqrtps<T, U>, 

VSQRTPS instruction

Instruction	Opcode	CPUID
VSQRTPS xmm1, xmm2/m128	VEX.128.0F.WIG 51 /r	AVX
VSQRTPS ymm1, ymm2/m256	VEX.256.0F.WIG 51 /r	AVX
VSQRTPS xmm1 {k1}{z}, xmm2/m128/m32bcst	EVEX.128.0F.W0 51 /r	AVX512VL AVX512F
VSQRTPS ymm1 {k1}{z}, ymm2/m256/m32bcst	EVEX.256.0F.W0 51 /r	AVX512VL AVX512F
VSQRTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}	EVEX.512.0F.W0 51 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vsqrtsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVsqrtsd<T, U, V>, 

VSQRTSD instruction

Instruction	Opcode	CPUID
VSQRTSD xmm1, xmm2, xmm3/m64	VEX.LIG.F2.0F.WIG 51 /r	AVX
VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.F2.0F.W1 51 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vsqrtsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVsqrtsh<T, U, V>, 

VSQRTSH instruction

Instruction	Opcode	CPUID
VSQRTSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.F3.MAP5.W0 51 /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vsqrtss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVsqrtss<T, U, V>, 

VSQRTSS instruction

Instruction	Opcode	CPUID
VSQRTSS xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 51 /r	AVX
VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.F3.0F.W0 51 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vstmxcsr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmVstmxcsr<T>, 

VSTMXCSR instruction

Instruction	Opcode	CPUID
VSTMXCSR m32	VEX.LZ.0F.WIG AE /3	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn vsubpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVsubpd<T, U, V>, 

VSUBPD instruction

Instruction	Opcode	CPUID
VSUBPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 5C /r	AVX
VSUBPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 5C /r	AVX
VSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 5C /r	AVX512VL AVX512F
VSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 5C /r	AVX512VL AVX512F
VSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}	EVEX.512.66.0F.W1 5C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vsubph<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVsubph<T, U, V>, 

VSUBPH instruction

Instruction	Opcode	CPUID
VSUBPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcst	EVEX.128.MAP5.W0 5C /r	AVX512VL AVX512-FP16
VSUBPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcst	EVEX.256.MAP5.W0 5C /r	AVX512VL AVX512-FP16
VSUBPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}	EVEX.512.MAP5.W0 5C /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vsubps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVsubps<T, U, V>, 

VSUBPS instruction

Instruction	Opcode	CPUID
VSUBPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 5C /r	AVX
VSUBPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 5C /r	AVX
VSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 5C /r	AVX512VL AVX512F
VSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 5C /r	AVX512VL AVX512F
VSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}	EVEX.512.0F.W0 5C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vsubsd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVsubsd<T, U, V>, 

VSUBSD instruction

Instruction	Opcode	CPUID
VSUBSD xmm1, xmm2, xmm3/m64	VEX.LIG.F2.0F.WIG 5C /r	AVX
VSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}	EVEX.LIG.F2.0F.W1 5C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vsubsh<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVsubsh<T, U, V>, 

VSUBSH instruction

Instruction	Opcode	CPUID
VSUBSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}	EVEX.LIG.F3.MAP5.W0 5C /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vsubss<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVsubss<T, U, V>, 

VSUBSS instruction

Instruction	Opcode	CPUID
VSUBSS xmm1, xmm2, xmm3/m32	VEX.LIG.F3.0F.WIG 5C /r	AVX
VSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}	EVEX.LIG.F3.0F.W0 5C /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vtestpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVtestpd<T, U>, 

VTESTPD instruction

Instruction	Opcode	CPUID
VTESTPD xmm1, xmm2/m128	VEX.128.66.0F38.W0 0F /r	AVX
VTESTPD ymm1, ymm2/m256	VEX.256.66.0F38.W0 0F /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vtestps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVtestps<T, U>, 

VTESTPS instruction

Instruction	Opcode	CPUID
VTESTPS xmm1, xmm2/m128	VEX.128.66.0F38.W0 0E /r	AVX
VTESTPS ymm1, ymm2/m256	VEX.256.66.0F38.W0 0E /r	AVX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vucomisd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVucomisd<T, U>, 

VUCOMISD instruction

Instruction	Opcode	CPUID
VUCOMISD xmm1, xmm2/m64	VEX.LIG.66.0F.WIG 2E /r	AVX
VUCOMISD xmm1, xmm2/m64{sae}	EVEX.LIG.66.0F.W1 2E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vucomish<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVucomish<T, U>, 

VUCOMISH instruction

Instruction	Opcode	CPUID
VUCOMISH xmm1, xmm2/m16{sae}	EVEX.LIG.MAP5.W0 2E /r	AVX512-FP16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vucomiss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmVucomiss<T, U>, 

VUCOMISS instruction

Instruction	Opcode	CPUID
VUCOMISS xmm1, xmm2/m32	VEX.LIG.0F.WIG 2E /r	AVX
VUCOMISS xmm1, xmm2/m32{sae}	EVEX.LIG.0F.W0 2E /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn vunpckhpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVunpckhpd<T, U, V>, 

VUNPCKHPD instruction

Instruction	Opcode	CPUID
VUNPCKHPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 15 /r	AVX
VUNPCKHPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 15 /r	AVX
VUNPCKHPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 15 /r	AVX512VL AVX512F
VUNPCKHPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 15 /r	AVX512VL AVX512F
VUNPCKHPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 15 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vunpckhps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVunpckhps<T, U, V>, 

VUNPCKHPS instruction

Instruction	Opcode	CPUID
VUNPCKHPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 15 /r	AVX
VUNPCKHPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 15 /r	AVX
VUNPCKHPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 15 /r	AVX512VL AVX512F
VUNPCKHPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 15 /r	AVX512VL AVX512F
VUNPCKHPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.0F.W0 15 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vunpcklpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVunpcklpd<T, U, V>, 

VUNPCKLPD instruction

Instruction	Opcode	CPUID
VUNPCKLPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 14 /r	AVX
VUNPCKLPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 14 /r	AVX
VUNPCKLPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 14 /r	AVX512VL AVX512F
VUNPCKLPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 14 /r	AVX512VL AVX512F
VUNPCKLPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 14 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vunpcklps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVunpcklps<T, U, V>, 

VUNPCKLPS instruction

Instruction	Opcode	CPUID
VUNPCKLPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 14 /r	AVX
VUNPCKLPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 14 /r	AVX
VUNPCKLPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 14 /r	AVX512VL AVX512F
VUNPCKLPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 14 /r	AVX512VL AVX512F
VUNPCKLPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.0F.W0 14 /r	AVX512F

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vxorpd<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVxorpd<T, U, V>, 

VXORPD instruction

Instruction	Opcode	CPUID
VXORPD xmm1, xmm2, xmm3/m128	VEX.128.66.0F.WIG 57 /r	AVX
VXORPD ymm1, ymm2, ymm3/m256	VEX.256.66.0F.WIG 57 /r	AVX
VXORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst	EVEX.128.66.0F.W1 57 /r	AVX512VL AVX512DQ
VXORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst	EVEX.256.66.0F.W1 57 /r	AVX512VL AVX512DQ
VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst	EVEX.512.66.0F.W1 57 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vxorps<T, U, V>(
    &mut self,
    op0: T,
    op1: U,
    op2: V
) -> Result<(), IcedError> where
    Self: CodeAsmVxorps<T, U, V>, 

VXORPS instruction

Instruction	Opcode	CPUID
VXORPS xmm1, xmm2, xmm3/m128	VEX.128.0F.WIG 57 /r	AVX
VXORPS ymm1, ymm2, ymm3/m256	VEX.256.0F.WIG 57 /r	AVX
VXORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst	EVEX.128.0F.W0 57 /r	AVX512VL AVX512DQ
VXORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst	EVEX.256.0F.W0 57 /r	AVX512VL AVX512DQ
VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst	EVEX.512.0F.W0 57 /r	AVX512DQ

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third operand

pub fn vzeroall(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVzeroall, 

VZEROALL instruction

Instruction	Opcode	CPUID
VZEROALL	VEX.256.0F.WIG 77	AVX

Errors

Fails if an operand is invalid (basic checks only)

pub fn vzeroupper(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmVzeroupper, 

VZEROUPPER instruction

Instruction	Opcode	CPUID
VZEROUPPER	VEX.128.0F.WIG 77	AVX

Errors

Fails if an operand is invalid (basic checks only)

pub fn wait(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmWait, 

WAIT instruction

Instruction	Opcode	CPUID
WAIT	9B	8086+

Errors

Fails if an operand is invalid (basic checks only)

pub fn wbinvd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmWbinvd, 

WBINVD instruction

Instruction	Opcode	CPUID
WBINVD	0F 09	486+

Errors

Fails if an operand is invalid (basic checks only)

pub fn wbnoinvd(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmWbnoinvd, 

WBNOINVD instruction

Instruction	Opcode	CPUID
WBNOINVD	F3 0F 09	WBNOINVD

Errors

Fails if an operand is invalid (basic checks only)

pub fn wrfsbase<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmWrfsbase<T>, 

WRFSBASE instruction

Instruction	Opcode	CPUID
WRFSBASE r32	F3 0F AE /2	FSGSBASE
WRFSBASE r64	F3 o64 0F AE /2	FSGSBASE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn wrgsbase<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmWrgsbase<T>, 

WRGSBASE instruction

Instruction	Opcode	CPUID
WRGSBASE r32	F3 0F AE /3	FSGSBASE
WRGSBASE r64	F3 o64 0F AE /3	FSGSBASE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn wrmsr(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmWrmsr, 

WRMSR instruction

Instruction	Opcode	CPUID
WRMSR	0F 30	MSR

Errors

Fails if an operand is invalid (basic checks only)

pub fn wrpkru(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmWrpkru, 

WRPKRU instruction

Instruction	Opcode	CPUID
WRPKRU	NP 0F 01 EF	PKU

Errors

Fails if an operand is invalid (basic checks only)

pub fn wrshr<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmWrshr<T>, 

WRSHR instruction

Instruction	Opcode	CPUID
WRSHR r/m32	0F 37 /0	Cyrix 6x86MX, M II, III

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn wrssd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmWrssd<T, U>, 

WRSSD instruction

Instruction	Opcode	CPUID
WRSSD m32, r32	NP 0F 38 F6 /r	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn wrssq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmWrssq<T, U>, 

WRSSQ instruction

Instruction	Opcode	CPUID
WRSSQ m64, r64	NP o64 0F 38 F6 /r	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn wrudbg(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmWrudbg, 

WRUDBG instruction

Instruction	Opcode	CPUID
WRUDBG	0F 0F	UDBG

Errors

Fails if an operand is invalid (basic checks only)

pub fn wrussd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmWrussd<T, U>, 

WRUSSD instruction

Instruction	Opcode	CPUID
WRUSSD m32, r32	66 0F 38 F5 /r	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn wrussq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmWrussq<T, U>, 

WRUSSQ instruction

Instruction	Opcode	CPUID
WRUSSQ m64, r64	66 o64 0F 38 F5 /r	CET_SS

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn xabort<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXabort<T>, 

XABORT instruction

Instruction	Opcode	CPUID
XABORT imm8	C6 F8 ib	RTM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xadd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmXadd<T, U>, 

XADD instruction

Instruction	Opcode	CPUID
XADD r/m8, r8	0F C0 /r	486+
XADD r/m16, r16	o16 0F C1 /r	486+
XADD r/m32, r32	o32 0F C1 /r	486+
XADD r/m64, r64	o64 0F C1 /r	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn xbegin<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXbegin<T>, 

XBEGIN instruction

Instruction	Opcode	CPUID
XBEGIN rel16	o16 C7 F8 cw	RTM
XBEGIN rel32	o32 C7 F8 cd	RTM

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xbts<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmXbts<T, U>, 

XBTS instruction

Instruction	Opcode	CPUID
XBTS r16, r/m16	o16 0F A6 /r	386 A0
XBTS r32, r/m32	o32 0F A6 /r	386 A0

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn xchg<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmXchg<T, U>, 

XCHG instruction

Instruction	Opcode	CPUID
XCHG r/m8, r8	86 /r	8086+
XCHG r/m16, r16	o16 87 /r	8086+
XCHG r/m32, r32	o32 87 /r	386+
XCHG r/m64, r64	o64 87 /r	X64
XCHG r16, AX	o16 90+rw	8086+
XCHG r32, EAX	o32 90+rd	386+
XCHG r64, RAX	o64 90+ro	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn xcryptcbc(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXcryptcbc, 

XCRYPTCBC instruction

Instruction	Opcode	CPUID
XCRYPTCBC	a16 F3 0F A7 D0	PADLOCK_ACE
XCRYPTCBC	a32 F3 0F A7 D0	PADLOCK_ACE
XCRYPTCBC	a64 F3 0F A7 D0	PADLOCK_ACE

Errors

Fails if an operand is invalid (basic checks only)

pub fn xcryptcfb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXcryptcfb, 

XCRYPTCFB instruction

Instruction	Opcode	CPUID
XCRYPTCFB	a16 F3 0F A7 E0	PADLOCK_ACE
XCRYPTCFB	a32 F3 0F A7 E0	PADLOCK_ACE
XCRYPTCFB	a64 F3 0F A7 E0	PADLOCK_ACE

Errors

Fails if an operand is invalid (basic checks only)

pub fn xcryptctr(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXcryptctr, 

XCRYPTCTR instruction

Instruction	Opcode	CPUID
XCRYPTCTR	a16 F3 0F A7 D8	PADLOCK_ACE
XCRYPTCTR	a32 F3 0F A7 D8	PADLOCK_ACE
XCRYPTCTR	a64 F3 0F A7 D8	PADLOCK_ACE

Errors

Fails if an operand is invalid (basic checks only)

pub fn xcryptecb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXcryptecb, 

XCRYPTECB instruction

Instruction	Opcode	CPUID
XCRYPTECB	a16 F3 0F A7 C8	PADLOCK_ACE
XCRYPTECB	a32 F3 0F A7 C8	PADLOCK_ACE
XCRYPTECB	a64 F3 0F A7 C8	PADLOCK_ACE

Errors

Fails if an operand is invalid (basic checks only)

pub fn xcryptofb(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXcryptofb, 

XCRYPTOFB instruction

Instruction	Opcode	CPUID
XCRYPTOFB	a16 F3 0F A7 E8	PADLOCK_ACE
XCRYPTOFB	a32 F3 0F A7 E8	PADLOCK_ACE
XCRYPTOFB	a64 F3 0F A7 E8	PADLOCK_ACE

Errors

Fails if an operand is invalid (basic checks only)

pub fn xend(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXend, 

XEND instruction

Instruction	Opcode	CPUID
XEND	NP 0F 01 D5	RTM

Errors

Fails if an operand is invalid (basic checks only)

pub fn xgetbv(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXgetbv, 

XGETBV instruction

Instruction	Opcode	CPUID
XGETBV	NP 0F 01 D0	XSAVE

Errors

Fails if an operand is invalid (basic checks only)

pub fn xor<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmXor<T, U>, 

XOR instruction

Instruction	Opcode	CPUID
XOR r/m8, r8	30 /r	8086+
XOR r/m16, r16	o16 31 /r	8086+
XOR r/m32, r32	o32 31 /r	386+
XOR r/m64, r64	o64 31 /r	X64
XOR r8, r/m8	32 /r	8086+
XOR r16, r/m16	o16 33 /r	8086+
XOR r32, r/m32	o32 33 /r	386+
XOR r64, r/m64	o64 33 /r	X64
XOR AL, imm8	34 ib	8086+
XOR AX, imm16	o16 35 iw	8086+
XOR EAX, imm32	o32 35 id	386+
XOR RAX, imm32	o64 35 id	X64
XOR r/m8, imm8	80 /6 ib	8086+
XOR r/m16, imm16	o16 81 /6 iw	8086+
XOR r/m32, imm32	o32 81 /6 id	386+
XOR r/m64, imm32	o64 81 /6 id	X64
XOR r/m16, imm8	o16 83 /6 ib	8086+
XOR r/m32, imm8	o32 83 /6 ib	386+
XOR r/m64, imm8	o64 83 /6 ib	X64

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn xorpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmXorpd<T, U>, 

XORPD instruction

Instruction	Opcode	CPUID
XORPD xmm1, xmm2/m128	66 0F 57 /r	SSE2

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn xorps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError> where
    Self: CodeAsmXorps<T, U>, 

XORPS instruction

Instruction	Opcode	CPUID
XORPS xmm1, xmm2/m128	NP 0F 57 /r	SSE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand

pub fn xresldtrk(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXresldtrk, 

XRESLDTRK instruction

Instruction	Opcode	CPUID
XRESLDTRK	F2 0F 01 E9	TSXLDTRK

Errors

Fails if an operand is invalid (basic checks only)

pub fn xrstor<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXrstor<T>, 

XRSTOR instruction

Instruction	Opcode	CPUID
XRSTOR mem	NP 0F AE /5	XSAVE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xrstor64<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXrstor64<T>, 

XRSTOR64 instruction

Instruction	Opcode	CPUID
XRSTOR64 mem	NP o64 0F AE /5	XSAVE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xrstors<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXrstors<T>, 

XRSTORS instruction

Instruction	Opcode	CPUID
XRSTORS mem	NP 0F C7 /3	XSAVES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xrstors64<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXrstors64<T>, 

XRSTORS64 instruction

Instruction	Opcode	CPUID
XRSTORS64 mem	NP o64 0F C7 /3	XSAVES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xsave<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXsave<T>, 

XSAVE instruction

Instruction	Opcode	CPUID
XSAVE mem	NP 0F AE /4	XSAVE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xsave64<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXsave64<T>, 

XSAVE64 instruction

Instruction	Opcode	CPUID
XSAVE64 mem	NP o64 0F AE /4	XSAVE

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xsavec<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXsavec<T>, 

XSAVEC instruction

Instruction	Opcode	CPUID
XSAVEC mem	NP 0F C7 /4	XSAVEC

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xsavec64<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXsavec64<T>, 

XSAVEC64 instruction

Instruction	Opcode	CPUID
XSAVEC64 mem	NP o64 0F C7 /4	XSAVEC

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xsaveopt<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXsaveopt<T>, 

XSAVEOPT instruction

Instruction	Opcode	CPUID
XSAVEOPT mem	NP 0F AE /6	XSAVEOPT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xsaveopt64<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXsaveopt64<T>, 

XSAVEOPT64 instruction

Instruction	Opcode	CPUID
XSAVEOPT64 mem	NP o64 0F AE /6	XSAVEOPT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xsaves<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXsaves<T>, 

XSAVES instruction

Instruction	Opcode	CPUID
XSAVES mem	NP 0F C7 /5	XSAVES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xsaves64<T>(&mut self, op0: T) -> Result<(), IcedError> where
    Self: CodeAsmXsaves64<T>, 

XSAVES64 instruction

Instruction	Opcode	CPUID
XSAVES64 mem	NP o64 0F C7 /5	XSAVES

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)

pub fn xsetbv(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXsetbv, 

XSETBV instruction

Instruction	Opcode	CPUID
XSETBV	NP 0F 01 D1	XSAVE

Errors

Fails if an operand is invalid (basic checks only)

pub fn xsha1(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXsha1, 

XSHA1 instruction

Instruction	Opcode	CPUID
XSHA1	a16 F3 0F A6 C8	PADLOCK_PHE
XSHA1	a32 F3 0F A6 C8	PADLOCK_PHE
XSHA1	a64 F3 0F A6 C8	PADLOCK_PHE

Errors

Fails if an operand is invalid (basic checks only)

pub fn xsha256(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXsha256, 

XSHA256 instruction

Instruction	Opcode	CPUID
XSHA256	a16 F3 0F A6 D0	PADLOCK_PHE
XSHA256	a32 F3 0F A6 D0	PADLOCK_PHE
XSHA256	a64 F3 0F A6 D0	PADLOCK_PHE

Errors

Fails if an operand is invalid (basic checks only)

pub fn xstore(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXstore, 

XSTORE instruction

Instruction	Opcode	CPUID
XSTORE	a16 0F A7 C0	PADLOCK_RNG
XSTORE	a32 0F A7 C0	PADLOCK_RNG
XSTORE	a64 0F A7 C0	PADLOCK_RNG

Errors

Fails if an operand is invalid (basic checks only)

pub fn xsusldtrk(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXsusldtrk, 

XSUSLDTRK instruction

Instruction	Opcode	CPUID
XSUSLDTRK	F2 0F 01 E8	TSXLDTRK

Errors

Fails if an operand is invalid (basic checks only)

pub fn xtest(&mut self) -> Result<(), IcedError> where
    Self: CodeAsmXtest, 

XTEST instruction

Instruction	Opcode	CPUID
XTEST	NP 0F 01 D6	HLE or RTM

Errors

Fails if an operand is invalid (basic checks only)