Struct CodeAssembler

pub struct CodeAssembler { /* private fields */ }

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.21.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 assemble_options( &mut self, ip: u64, options: u32, ) -> Result<CodeAssemblerResult, 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
• options: BlockEncoderOptions flags

Examples

use iced_x86::BlockEncoderOptions;
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 result = a.assemble_options(0x1234_5678, BlockEncoderOptions::RETURN_NEW_INSTRUCTION_OFFSETS)?;
assert_eq!(result.inner.rip, 0x1234_5678);
assert_eq!(result.inner.code_buffer, b"\x51\x48\x31\xD1\x74\xFB\x90");
// Get the address of the label, requires `BlockEncoderOptions::RETURN_NEW_INSTRUCTION_OFFSETS`
assert_eq!(result.label_ip(&label1)?, 0x1234_5679);

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 aadd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmAadd<T, U>,

AADD instruction

Instruction	Opcode	CPUID
AADD m32, r32	NP 0F 38 FC !(11):rrr:bbb	RAO-INT
AADD m64, r64	NP o64 0F 38 FC !(11):rrr:bbb	RAO-INT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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 aand<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmAand<T, U>,

AAND instruction

Instruction	Opcode	CPUID
AAND m32, r32	66 0F 38 FC !(11):rrr:bbb	RAO-INT
AAND m64, r64	66 o64 0F 38 FC !(11):rrr:bbb	RAO-INT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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 aor<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmAor<T, U>,

AOR instruction

Instruction	Opcode	CPUID
AOR m32, r32	F2 0F 38 FC !(11):rrr:bbb	RAO-INT
AOR m64, r64	F2 o64 0F 38 FC !(11):rrr:bbb	RAO-INT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/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 axor<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmAxor<T, U>,

AXOR instruction

Instruction	Opcode	CPUID
AXOR m32, r32	F3 0F 38 FC !(11):rrr:bbb	RAO-INT
AXOR m64, r64	F3 o64 0F 38 FC !(11):rrr:bbb	RAO-INT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/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 cmpbexadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmpbexadd<T, U, V>,

CMPBEXADD instruction

Instruction	Opcode	CPUID
CMPBEXADD m32, r32, r32	VEX.128.66.0F38.W0 E6 !(11):rrr:bbb	CMPCCXADD
CMPBEXADD m64, r64, r64	VEX.128.66.0F38.W1 E6 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpbxadd<T, U, V>,

CMPBXADD instruction

Instruction	Opcode	CPUID
CMPBXADD m32, r32, r32	VEX.128.66.0F38.W0 E2 !(11):rrr:bbb	CMPCCXADD
CMPBXADD m64, r64, r64	VEX.128.66.0F38.W1 E2 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpcxadd<T, U, V>,

CMPCXADD instruction

Instruction	Opcode	CPUID
CMPBXADD m32, r32, r32	VEX.128.66.0F38.W0 E2 !(11):rrr:bbb	CMPCCXADD
CMPBXADD m64, r64, r64	VEX.128.66.0F38.W1 E2 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 cmplexadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmplexadd<T, U, V>,

CMPLEXADD instruction

Instruction	Opcode	CPUID
CMPLEXADD m32, r32, r32	VEX.128.66.0F38.W0 EE !(11):rrr:bbb	CMPCCXADD
CMPLEXADD m64, r64, r64	VEX.128.66.0F38.W1 EE !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 cmplxadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmplxadd<T, U, V>,

CMPLXADD instruction

Instruction	Opcode	CPUID
CMPLXADD m32, r32, r32	VEX.128.66.0F38.W0 EC !(11):rrr:bbb	CMPCCXADD
CMPLXADD m64, r64, r64	VEX.128.66.0F38.W1 EC !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpnaexadd<T, U, V>,

CMPNAEXADD instruction

Instruction	Opcode	CPUID
CMPBXADD m32, r32, r32	VEX.128.66.0F38.W0 E2 !(11):rrr:bbb	CMPCCXADD
CMPBXADD m64, r64, r64	VEX.128.66.0F38.W1 E2 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpnaxadd<T, U, V>,

CMPNAXADD instruction

Instruction	Opcode	CPUID
CMPBEXADD m32, r32, r32	VEX.128.66.0F38.W0 E6 !(11):rrr:bbb	CMPCCXADD
CMPBEXADD m64, r64, r64	VEX.128.66.0F38.W1 E6 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpnbexadd<T, U, V>,

CMPNBEXADD instruction

Instruction	Opcode	CPUID
CMPNBEXADD m32, r32, r32	VEX.128.66.0F38.W0 E7 !(11):rrr:bbb	CMPCCXADD
CMPNBEXADD m64, r64, r64	VEX.128.66.0F38.W1 E7 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpnbxadd<T, U, V>,

CMPNBXADD instruction

Instruction	Opcode	CPUID
CMPNBXADD m32, r32, r32	VEX.128.66.0F38.W0 E3 !(11):rrr:bbb	CMPCCXADD
CMPNBXADD m64, r64, r64	VEX.128.66.0F38.W1 E3 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpncxadd<T, U, V>,

CMPNCXADD instruction

Instruction	Opcode	CPUID
CMPNBXADD m32, r32, r32	VEX.128.66.0F38.W0 E3 !(11):rrr:bbb	CMPCCXADD
CMPNBXADD m64, r64, r64	VEX.128.66.0F38.W1 E3 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 cmpngexadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmpngexadd<T, U, V>,

CMPNGEXADD instruction

Instruction	Opcode	CPUID
CMPLXADD m32, r32, r32	VEX.128.66.0F38.W0 EC !(11):rrr:bbb	CMPCCXADD
CMPLXADD m64, r64, r64	VEX.128.66.0F38.W1 EC !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpngxadd<T, U, V>,

CMPNGXADD instruction

Instruction	Opcode	CPUID
CMPLEXADD m32, r32, r32	VEX.128.66.0F38.W0 EE !(11):rrr:bbb	CMPCCXADD
CMPLEXADD m64, r64, r64	VEX.128.66.0F38.W1 EE !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 cmpnlexadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmpnlexadd<T, U, V>,

CMPNLEXADD instruction

Instruction	Opcode	CPUID
CMPNLEXADD m32, r32, r32	VEX.128.66.0F38.W0 EF !(11):rrr:bbb	CMPCCXADD
CMPNLEXADD m64, r64, r64	VEX.128.66.0F38.W1 EF !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 cmpnlxadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmpnlxadd<T, U, V>,

CMPNLXADD instruction

Instruction	Opcode	CPUID
CMPNLXADD m32, r32, r32	VEX.128.66.0F38.W0 ED !(11):rrr:bbb	CMPCCXADD
CMPNLXADD m64, r64, r64	VEX.128.66.0F38.W1 ED !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpnoxadd<T, U, V>,

CMPNOXADD instruction

Instruction	Opcode	CPUID
CMPNOXADD m32, r32, r32	VEX.128.66.0F38.W0 E1 !(11):rrr:bbb	CMPCCXADD
CMPNOXADD m64, r64, r64	VEX.128.66.0F38.W1 E1 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpnpxadd<T, U, V>,

CMPNPXADD instruction

Instruction	Opcode	CPUID
CMPNPXADD m32, r32, r32	VEX.128.66.0F38.W0 EB !(11):rrr:bbb	CMPCCXADD
CMPNPXADD m64, r64, r64	VEX.128.66.0F38.W1 EB !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpnsxadd<T, U, V>,

CMPNSXADD instruction

Instruction	Opcode	CPUID
CMPNSXADD m32, r32, r32	VEX.128.66.0F38.W0 E9 !(11):rrr:bbb	CMPCCXADD
CMPNSXADD m64, r64, r64	VEX.128.66.0F38.W1 E9 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmpnzxadd<T, U, V>,

CMPNZXADD instruction

Instruction	Opcode	CPUID
CMPNZXADD m32, r32, r32	VEX.128.66.0F38.W0 E5 !(11):rrr:bbb	CMPCCXADD
CMPNZXADD m64, r64, r64	VEX.128.66.0F38.W1 E5 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 cmpoxadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmpoxadd<T, U, V>,

CMPOXADD instruction

Instruction	Opcode	CPUID
CMPOXADD m32, r32, r32	VEX.128.66.0F38.W0 E0 !(11):rrr:bbb	CMPCCXADD
CMPOXADD m64, r64, r64	VEX.128.66.0F38.W1 E0 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 cmppexadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmppexadd<T, U, V>,

CMPPEXADD instruction

Instruction	Opcode	CPUID
CMPPXADD m32, r32, r32	VEX.128.66.0F38.W0 EA !(11):rrr:bbb	CMPCCXADD
CMPPXADD m64, r64, r64	VEX.128.66.0F38.W1 EA !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmCmppoxadd<T, U, V>,

CMPPOXADD instruction

Instruction	Opcode	CPUID
CMPNPXADD m32, r32, r32	VEX.128.66.0F38.W0 EB !(11):rrr:bbb	CMPCCXADD
CMPNPXADD m64, r64, r64	VEX.128.66.0F38.W1 EB !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number 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 cmppxadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmppxadd<T, U, V>,

CMPPXADD instruction

Instruction	Opcode	CPUID
CMPPXADD m32, r32, r32	VEX.128.66.0F38.W0 EA !(11):rrr:bbb	CMPCCXADD
CMPPXADD m64, r64, r64	VEX.128.66.0F38.W1 EA !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number 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 cmpsxadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmpsxadd<T, U, V>,

CMPSXADD instruction

Instruction	Opcode	CPUID
CMPSXADD m32, r32, r32	VEX.128.66.0F38.W0 E8 !(11):rrr:bbb	CMPCCXADD
CMPSXADD m64, r64, r64	VEX.128.66.0F38.W1 E8 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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 cmpzxadd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmCmpzxadd<T, U, V>,

CMPZXADD instruction

Instruction	Opcode	CPUID
CMPZXADD m32, r32, r32	VEX.128.66.0F38.W0 E4 !(11):rrr:bbb	CMPCCXADD
CMPZXADD m64, r64, r64	VEX.128.66.0F38.W1 E4 !(11):rrr:bbb	CMPCCXADD

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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 pbndkb(&mut self) -> Result<(), IcedError>

where Self: CodeAsmPbndkb,

PBNDKB instruction

Instruction	Opcode	CPUID
PBNDKB	NP 0F 01 C7	TSE

Errors

Fails if an operand is invalid (basic checks only)

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 prefetchit0<T>(&mut self, op0: T) -> Result<(), IcedError>

where Self: CodeAsmPrefetchit0<T>,

PREFETCHIT0 instruction

Instruction	Opcode	CPUID
PREFETCHIT0 m8	0F 18 /7	PREFETCHITI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (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 prefetchit1<T>(&mut self, op0: T) -> Result<(), IcedError>

where Self: CodeAsmPrefetchit1<T>,

PREFETCHIT1 instruction

Instruction	Opcode	CPUID
PREFETCHIT1 m8	0F 18 /6	PREFETCHITI

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (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 rdmsrlist(&mut self) -> Result<(), IcedError>

where Self: CodeAsmRdmsrlist,

RDMSRLIST instruction

Instruction	Opcode	CPUID
RDMSRLIST	F2 0F 01 C6	MSRLIST

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	NP 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 rmpquery(&mut self) -> Result<(), IcedError>

where Self: CodeAsmRmpquery,

RMPQUERY instruction

Instruction	Opcode	CPUID
RMPQUERY	F3 0F 01 FD	RMPQUERY

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 tcmmimfp16ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmTcmmimfp16ps<T, U, V>,

TCMMIMFP16PS instruction

Instruction	Opcode	CPUID
TCMMIMFP16PS tmm1, tmm2, tmm3	VEX.128.66.0F38.W0 6C 11:rrr:bbb	AMX-COMPLEX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmTcmmrlfp16ps<T, U, V>,

TCMMRLFP16PS instruction

Instruction	Opcode	CPUID
TCMMRLFP16PS tmm1, tmm2, tmm3	VEX.128.0F38.W0 6C 11:rrr:bbb	AMX-COMPLEX

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 tdpfp16ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmTdpfp16ps<T, U, V>,

TDPFP16PS instruction

Instruction	Opcode	CPUID
TDPFP16PS tmm1, tmm2, tmm3	VEX.128.F2.0F38.W0 5C 11:rrr:bbb	AMX-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 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 vbcstnebf162ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmVbcstnebf162ps<T, U>,

VBCSTNEBF162PS instruction

Instruction	Opcode	CPUID
VBCSTNEBF162PS xmm1, m16	VEX.128.F3.0F38.W0 B1 !(11):rrr:bbb	AVX-NE-CONVERT
VBCSTNEBF162PS ymm1, m16	VEX.256.F3.0F38.W0 B1 !(11):rrr:bbb	AVX-NE-CONVERT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

pub fn vbcstnesh2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmVbcstnesh2ps<T, U>,

VBCSTNESH2PS instruction

Instruction	Opcode	CPUID
VBCSTNESH2PS xmm1, m16	VEX.128.66.0F38.W0 B1 !(11):rrr:bbb	AVX-NE-CONVERT
VBCSTNESH2PS ymm1, m16	VEX.256.66.0F38.W0 B1 !(11):rrr:bbb	AVX-NE-CONVERT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second 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 vcvtneebf162ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmVcvtneebf162ps<T, U>,

VCVTNEEBF162PS instruction

Instruction	Opcode	CPUID
VCVTNEEBF162PS xmm1, m128	VEX.128.F3.0F38.W0 B0 !(11):rrr:bbb	AVX-NE-CONVERT
VCVTNEEBF162PS ymm1, m256	VEX.256.F3.0F38.W0 B0 !(11):rrr:bbb	AVX-NE-CONVERT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

pub fn vcvtneeph2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmVcvtneeph2ps<T, U>,

VCVTNEEPH2PS instruction

Instruction	Opcode	CPUID
VCVTNEEPH2PS xmm1, m128	VEX.128.66.0F38.W0 B0 !(11):rrr:bbb	AVX-NE-CONVERT
VCVTNEEPH2PS ymm1, m256	VEX.256.66.0F38.W0 B0 !(11):rrr:bbb	AVX-NE-CONVERT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

pub fn vcvtneobf162ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmVcvtneobf162ps<T, U>,

VCVTNEOBF162PS instruction

Instruction	Opcode	CPUID
VCVTNEOBF162PS xmm1, m128	VEX.128.F2.0F38.W0 B0 !(11):rrr:bbb	AVX-NE-CONVERT
VCVTNEOBF162PS ymm1, m256	VEX.256.F2.0F38.W0 B0 !(11):rrr:bbb	AVX-NE-CONVERT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

pub fn vcvtneoph2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmVcvtneoph2ps<T, U>,

VCVTNEOPH2PS instruction

Instruction	Opcode	CPUID
VCVTNEOPH2PS xmm1, m128	VEX.128.0F38.W0 B0 !(11):rrr:bbb	AVX-NE-CONVERT
VCVTNEOPH2PS ymm1, m256	VEX.256.0F38.W0 B0 !(11):rrr:bbb	AVX-NE-CONVERT

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second 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, xmm2/m128	VEX.128.F3.0F38.W0 72 /r	AVX-NE-CONVERT
VCVTNEPS2BF16 xmm1, ymm2/m256	VEX.256.F3.0F38.W0 72 /r	AVX-NE-CONVERT
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 vpdpbssd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmVpdpbssd<T, U, V>,

VPDPBSSD instruction

Instruction	Opcode	CPUID
VPDPBSSD xmm1, xmm2, xmm3/m128	VEX.128.F2.0F38.W0 50 /r	AVX-VNNI-INT8
VPDPBSSD ymm1, ymm2, ymm3/m256	VEX.256.F2.0F38.W0 50 /r	AVX-VNNI-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 vpdpbssds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmVpdpbssds<T, U, V>,

VPDPBSSDS instruction

Instruction	Opcode	CPUID
VPDPBSSDS xmm1, xmm2, xmm3/m128	VEX.128.F2.0F38.W0 51 /r	AVX-VNNI-INT8
VPDPBSSDS ymm1, ymm2, ymm3/m256	VEX.256.F2.0F38.W0 51 /r	AVX-VNNI-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 vpdpbsud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmVpdpbsud<T, U, V>,

VPDPBSUD instruction

Instruction	Opcode	CPUID
VPDPBSUD xmm1, xmm2, xmm3/m128	VEX.128.F3.0F38.W0 50 /r	AVX-VNNI-INT8
VPDPBSUD ymm1, ymm2, ymm3/m256	VEX.256.F3.0F38.W0 50 /r	AVX-VNNI-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 vpdpbsuds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmVpdpbsuds<T, U, V>,

VPDPBSUDS instruction

Instruction	Opcode	CPUID
VPDPBSUDS xmm1, xmm2, xmm3/m128	VEX.128.F3.0F38.W0 51 /r	AVX-VNNI-INT8
VPDPBSUDS ymm1, ymm2, ymm3/m256	VEX.256.F3.0F38.W0 51 /r	AVX-VNNI-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 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 vpdpbuud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmVpdpbuud<T, U, V>,

VPDPBUUD instruction

Instruction	Opcode	CPUID
VPDPBUUD xmm1, xmm2, xmm3/m128	VEX.128.0F38.W0 50 /r	AVX-VNNI-INT8
VPDPBUUD ymm1, ymm2, ymm3/m256	VEX.256.0F38.W0 50 /r	AVX-VNNI-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 vpdpbuuds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmVpdpbuuds<T, U, V>,

VPDPBUUDS instruction

Instruction	Opcode	CPUID
VPDPBUUDS xmm1, xmm2, xmm3/m128	VEX.128.0F38.W0 51 /r	AVX-VNNI-INT8
VPDPBUUDS ymm1, ymm2, ymm3/m256	VEX.256.0F38.W0 51 /r	AVX-VNNI-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 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 vpdpwsud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmVpdpwsud<T, U, V>,

VPDPWSUD instruction

Instruction	Opcode	CPUID
VPDPWSUD xmm1, xmm2, xmm3/m128	VEX.128.F3.0F38.W0 D2 /r	AVX-VNNI-INT16
VPDPWSUD ymm1, ymm2, ymm3/m256	VEX.256.F3.0F38.W0 D2 /r	AVX-VNNI-INT16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmVpdpwsuds<T, U, V>,

VPDPWSUDS instruction

Instruction	Opcode	CPUID
VPDPWSUDS xmm1, xmm2, xmm3/m128	VEX.128.F3.0F38.W0 D3 /r	AVX-VNNI-INT16
VPDPWSUDS ymm1, ymm2, ymm3/m256	VEX.256.F3.0F38.W0 D3 /r	AVX-VNNI-INT16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmVpdpwusd<T, U, V>,

VPDPWUSD instruction

Instruction	Opcode	CPUID
VPDPWUSD xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 D2 /r	AVX-VNNI-INT16
VPDPWUSD ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 D2 /r	AVX-VNNI-INT16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmVpdpwusds<T, U, V>,

VPDPWUSDS instruction

Instruction	Opcode	CPUID
VPDPWUSDS xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 D3 /r	AVX-VNNI-INT16
VPDPWUSDS ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W0 D3 /r	AVX-VNNI-INT16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmVpdpwuud<T, U, V>,

VPDPWUUD instruction

Instruction	Opcode	CPUID
VPDPWUUD xmm1, xmm2, xmm3/m128	VEX.128.0F38.W0 D2 /r	AVX-VNNI-INT16
VPDPWUUD ymm1, ymm2, ymm3/m256	VEX.256.0F38.W0 D2 /r	AVX-VNNI-INT16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmVpdpwuuds<T, U, V>,

VPDPWUUDS instruction

Instruction	Opcode	CPUID
VPDPWUUDS xmm1, xmm2, xmm3/m128	VEX.128.0F38.W0 D3 /r	AVX-VNNI-INT16
VPDPWUUDS ymm1, ymm2, ymm3/m256	VEX.256.0F38.W0 D3 /r	AVX-VNNI-INT16

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number 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, xmm2, xmm3/m128	VEX.128.66.0F38.W1 B5 /r	AVX-IFMA
VPMADD52HUQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 B5 /r	AVX-IFMA
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, xmm2, xmm3/m128	VEX.128.66.0F38.W1 B4 /r	AVX-IFMA
VPMADD52LUQ ymm1, ymm2, ymm3/m256	VEX.256.66.0F38.W1 B4 /r	AVX-IFMA
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 vsha512msg1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmVsha512msg1<T, U>,

VSHA512MSG1 instruction

Instruction	Opcode	CPUID
VSHA512MSG1 ymm1, xmm2	VEX.256.F2.0F38.W0 CC 11:rrr:bbb	AVX SHA512

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

pub fn vsha512msg2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>

where Self: CodeAsmVsha512msg2<T, U>,

VSHA512MSG2 instruction

Instruction	Opcode	CPUID
VSHA512MSG2 ymm1, ymm2	VEX.256.F2.0F38.W0 CD 11:rrr:bbb	AVX SHA512

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmVsha512rnds2<T, U, V>,

VSHA512RNDS2 instruction

Instruction	Opcode	CPUID
VSHA512RNDS2 ymm1, ymm2, xmm3	VEX.256.F2.0F38.W0 CB 11:rrr:bbb	AVX SHA512

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 vsm3msg1<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmVsm3msg1<T, U, V>,

VSM3MSG1 instruction

Instruction	Opcode	CPUID
VSM3MSG1 xmm1, xmm2, xmm3/m128	VEX.128.0F38.W0 DA /r	AVX SM3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmVsm3msg2<T, U, V>,

VSM3MSG2 instruction

Instruction	Opcode	CPUID
VSM3MSG2 xmm1, xmm2, xmm3/m128	VEX.128.66.0F38.W0 DA /r	AVX SM3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

pub fn vsm3rnds2<T, U, V, W>( &mut self, op0: T, op1: U, op2: V, op3: W, ) -> Result<(), IcedError>

where Self: CodeAsmVsm3rnds2<T, U, V, W>,

VSM3RNDS2 instruction

Instruction	Opcode	CPUID
VSM3RNDS2 xmm1, xmm2, xmm3/m128, imm8	VEX.128.66.0F3A.W0 DE /r ib	AVX SM3

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/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 vsm4key4<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>

where Self: CodeAsmVsm4key4<T, U, V>,

VSM4KEY4 instruction

Instruction	Opcode	CPUID
VSM4KEY4 xmm1, xmm2, xmm3/m128	VEX.128.F3.0F38.W0 DA /r	AVX SM4
VSM4KEY4 ymm1, ymm2, ymm3/m256	VEX.256.F3.0F38.W0 DA /r	AVX SM4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

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

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

where Self: CodeAsmVsm4rnds4<T, U, V>,

VSM4RNDS4 instruction

Instruction	Opcode	CPUID
VSM4RNDS4 xmm1, xmm2, xmm3/m128	VEX.128.F2.0F38.W0 DA /r	AVX SM4
VSM4RNDS4 ymm1, ymm2, ymm3/m256	VEX.256.F2.0F38.W0 DA /r	AVX SM4

Errors

Fails if an operand is invalid (basic checks only)

Arguments

• op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
• op1: Second operand
• op2: Third 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 wrmsrlist(&mut self) -> Result<(), IcedError>

where Self: CodeAsmWrmsrlist,

WRMSRLIST instruction

Instruction	Opcode	CPUID
WRMSRLIST	F3 0F 01 C6	MSRLIST

Errors

Fails if an operand is invalid (basic checks only)

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

where Self: CodeAsmWrmsrns,

WRMSRNS instruction

Instruction	Opcode	CPUID
WRMSRNS	NP 0F 01 C6	WRMSRNS

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 xsha512(&mut self) -> Result<(), IcedError>

where Self: CodeAsmXsha512,

XSHA512 instruction

Instruction	Opcode	CPUID
XSHA512	a16 F3 0F A6 E0	PADLOCK_PHE
XSHA512	a32 F3 0F A6 E0	PADLOCK_PHE
XSHA512	a64 F3 0F A6 E0	PADLOCK_PHE

Errors

Fails if an operand is invalid (basic checks only)

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

where Self: CodeAsmXsha512_alt,

XSHA512_ALT instruction

Instruction	Opcode	CPUID
XSHA512_ALT	a16 F3 0F A6 D8	PADLOCK_PHE
XSHA512_ALT	a32 F3 0F A6 D8	PADLOCK_PHE
XSHA512_ALT	a64 F3 0F A6 D8	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 xstore_alt(&mut self) -> Result<(), IcedError>

where Self: CodeAsmXstore_alt,

XSTORE_ALT instruction

Instruction	Opcode	CPUID
XSTORE_ALT	a16 F3 0F A7 F8	PADLOCK_RNG
XSTORE_ALT	a32 F3 0F A7 F8	PADLOCK_RNG
XSTORE_ALT	a64 F3 0F A7 F8	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)

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

where Self: CodeAsmZero_bytes,

ZERO_BYTES instruction

Instruction	Opcode	CPUID
ZERO_BYTES	<zero_bytes>	8086+

Errors

Fails if an operand is invalid (basic checks only)

Trait Implementations

impl CodeAsmAaa for CodeAssembler

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

impl CodeAsmAad<i32> for CodeAssembler

fn aad(&mut self, op0: i32) -> Result<(), IcedError>

impl CodeAsmAad<u32> for CodeAssembler

fn aad(&mut self, op0: u32) -> Result<(), IcedError>

impl CodeAsmAadd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn aadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAadd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn aadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAam<i32> for CodeAssembler

fn aam(&mut self, op0: i32) -> Result<(), IcedError>

impl CodeAsmAam<u32> for CodeAssembler

fn aam(&mut self, op0: u32) -> Result<(), IcedError>

impl CodeAsmAand<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn aand( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAand<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn aand( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAas for CodeAssembler

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

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn adc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn adc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn adc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn adc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, i32> for CodeAssembler

fn adc(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmMemoryOperand, u32> for CodeAssembler

fn adc(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn adc( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister16, AsmRegister16> for CodeAssembler

fn adc( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister16, i32> for CodeAssembler

fn adc(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister16, u32> for CodeAssembler

fn adc(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn adc( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister32, AsmRegister32> for CodeAssembler

fn adc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister32, i32> for CodeAssembler

fn adc(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister32, u32> for CodeAssembler

fn adc(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn adc( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister64, AsmRegister64> for CodeAssembler

fn adc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister64, i32> for CodeAssembler

fn adc(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn adc( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister8, AsmRegister8> for CodeAssembler

fn adc(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister8, i32> for CodeAssembler

fn adc(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdc<AsmRegister8, u32> for CodeAssembler

fn adc(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmAdcx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn adcx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdcx<AsmRegister32, AsmRegister32> for CodeAssembler

fn adcx( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAdcx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn adcx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdcx<AsmRegister64, AsmRegister64> for CodeAssembler

fn adcx( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn add( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn add( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn add( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn add( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, i32> for CodeAssembler

fn add(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmMemoryOperand, u32> for CodeAssembler

fn add(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn add( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister16, AsmRegister16> for CodeAssembler

fn add( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister16, i32> for CodeAssembler

fn add(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister16, u32> for CodeAssembler

fn add(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn add( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister32, AsmRegister32> for CodeAssembler

fn add( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister32, i32> for CodeAssembler

fn add(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister32, u32> for CodeAssembler

fn add(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn add( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister64, AsmRegister64> for CodeAssembler

fn add( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister64, i32> for CodeAssembler

fn add(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn add( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister8, AsmRegister8> for CodeAssembler

fn add(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister8, i32> for CodeAssembler

fn add(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmAdd<AsmRegister8, u32> for CodeAssembler

fn add(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmAddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAddpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn addpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAddps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn addps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAddsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAddsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn addsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAddss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAddss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn addss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAddsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAddsubpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn addsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAddsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn addsubps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAddsubps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn addsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAdox<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn adox( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdox<AsmRegister32, AsmRegister32> for CodeAssembler

fn adox( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAdox<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn adox( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAdox<AsmRegister64, AsmRegister64> for CodeAssembler

fn adox( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAesdec<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesdec( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAesdec<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn aesdec( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAesdec128kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesdec128kl( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAesdec256kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesdec256kl( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAesdeclast<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesdeclast( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAesdeclast<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn aesdeclast( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAesdecwide128kl<AsmMemoryOperand> for CodeAssembler

fn aesdecwide128kl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmAesdecwide256kl<AsmMemoryOperand> for CodeAssembler

fn aesdecwide256kl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmAesenc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesenc( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAesenc<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn aesenc( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAesenc128kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesenc128kl( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAesenc256kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesenc256kl( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAesenclast<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesenclast( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAesenclast<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn aesenclast( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAesencwide128kl<AsmMemoryOperand> for CodeAssembler

fn aesencwide128kl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmAesencwide256kl<AsmMemoryOperand> for CodeAssembler

fn aesencwide256kl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmAesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn aesimc( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAesimc<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn aesimc( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn aeskeygenassist( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn aeskeygenassist( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn aeskeygenassist( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn aeskeygenassist( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmAltinst for CodeAssembler

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

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn and( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn and( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn and( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn and( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, i32> for CodeAssembler

fn and(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmMemoryOperand, u32> for CodeAssembler

fn and(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn and( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister16, AsmRegister16> for CodeAssembler

fn and( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister16, i32> for CodeAssembler

fn and(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister16, u32> for CodeAssembler

fn and(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn and( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister32, AsmRegister32> for CodeAssembler

fn and( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister32, i32> for CodeAssembler

fn and(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister32, u32> for CodeAssembler

fn and(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn and( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister64, AsmRegister64> for CodeAssembler

fn and( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister64, i32> for CodeAssembler

fn and(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn and( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister8, AsmRegister8> for CodeAssembler

fn and(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister8, i32> for CodeAssembler

fn and(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmAnd<AsmRegister8, u32> for CodeAssembler

fn and(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmAndn<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn andn( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAndn<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

fn andn( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAndn<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn andn( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAndn<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

fn andn( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmAndnpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn andnpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAndnpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn andnpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAndnps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn andnps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAndnps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn andnps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAndpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn andpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAndpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn andpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAndps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn andps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmAndps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn andps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmAor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn aor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn aor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn arpl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn arpl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmArpl<AsmRegister16, AsmRegister16> for CodeAssembler

fn arpl( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmArpl<AsmRegister32, AsmRegister32> for CodeAssembler

fn arpl( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAxor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn axor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmAxor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn axor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBb0_reset for CodeAssembler

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

impl CodeAsmBb1_reset for CodeAssembler

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

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister32, AsmRegister32, i32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister32, AsmRegister32, u32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister64, AsmRegister64, i32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmBextr<AsmRegister64, AsmRegister64, u32> for CodeAssembler

fn bextr( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmBlcfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blcfill( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlcfill<AsmRegister32, AsmRegister32> for CodeAssembler

fn blcfill( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlcfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blcfill( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlcfill<AsmRegister64, AsmRegister64> for CodeAssembler

fn blcfill( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBlci<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blci( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlci<AsmRegister32, AsmRegister32> for CodeAssembler

fn blci( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlci<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blci( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlci<AsmRegister64, AsmRegister64> for CodeAssembler

fn blci( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBlcic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blcic( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlcic<AsmRegister32, AsmRegister32> for CodeAssembler

fn blcic( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlcic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blcic( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlcic<AsmRegister64, AsmRegister64> for CodeAssembler

fn blcic( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBlcmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blcmsk( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlcmsk<AsmRegister32, AsmRegister32> for CodeAssembler

fn blcmsk( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlcmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blcmsk( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlcmsk<AsmRegister64, AsmRegister64> for CodeAssembler

fn blcmsk( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBlcs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blcs( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlcs<AsmRegister32, AsmRegister32> for CodeAssembler

fn blcs( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlcs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blcs( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlcs<AsmRegister64, AsmRegister64> for CodeAssembler

fn blcs( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBlendpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn blendpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmBlendpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn blendpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmBlendpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn blendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmBlendpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn blendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmBlendps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn blendps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmBlendps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn blendps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmBlendps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn blendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmBlendps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn blendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmBlendvpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn blendvpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlendvpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn blendvpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmBlendvps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn blendvps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlendvps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn blendvps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmBlsfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsfill( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsfill<AsmRegister32, AsmRegister32> for CodeAssembler

fn blsfill( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlsfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsfill( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsfill<AsmRegister64, AsmRegister64> for CodeAssembler

fn blsfill( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBlsi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsi<AsmRegister32, AsmRegister32> for CodeAssembler

fn blsi( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlsi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsi<AsmRegister64, AsmRegister64> for CodeAssembler

fn blsi( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBlsic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsic( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsic<AsmRegister32, AsmRegister32> for CodeAssembler

fn blsic( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlsic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsic( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsic<AsmRegister64, AsmRegister64> for CodeAssembler

fn blsic( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBlsmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsmsk( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsmsk<AsmRegister32, AsmRegister32> for CodeAssembler

fn blsmsk( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlsmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsmsk( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsmsk<AsmRegister64, AsmRegister64> for CodeAssembler

fn blsmsk( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBlsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn blsr( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsr<AsmRegister32, AsmRegister32> for CodeAssembler

fn blsr( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBlsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn blsr( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBlsr<AsmRegister64, AsmRegister64> for CodeAssembler

fn blsr( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBndcl<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndcl( &mut self, op0: AsmRegisterBnd, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBndcl<AsmRegisterBnd, AsmRegister32> for CodeAssembler

fn bndcl( &mut self, op0: AsmRegisterBnd, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBndcl<AsmRegisterBnd, AsmRegister64> for CodeAssembler

fn bndcl( &mut self, op0: AsmRegisterBnd, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBndcn<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndcn( &mut self, op0: AsmRegisterBnd, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBndcn<AsmRegisterBnd, AsmRegister32> for CodeAssembler

fn bndcn( &mut self, op0: AsmRegisterBnd, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBndcn<AsmRegisterBnd, AsmRegister64> for CodeAssembler

fn bndcn( &mut self, op0: AsmRegisterBnd, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBndcu<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndcu( &mut self, op0: AsmRegisterBnd, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBndcu<AsmRegisterBnd, AsmRegister32> for CodeAssembler

fn bndcu( &mut self, op0: AsmRegisterBnd, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBndcu<AsmRegisterBnd, AsmRegister64> for CodeAssembler

fn bndcu( &mut self, op0: AsmRegisterBnd, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBndldx<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndldx( &mut self, op0: AsmRegisterBnd, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBndmk<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndmk( &mut self, op0: AsmRegisterBnd, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBndmov<AsmMemoryOperand, AsmRegisterBnd> for CodeAssembler

fn bndmov( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterBnd, ) -> Result<(), IcedError>

impl CodeAsmBndmov<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

fn bndmov( &mut self, op0: AsmRegisterBnd, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBndmov<AsmRegisterBnd, AsmRegisterBnd> for CodeAssembler

fn bndmov( &mut self, op0: AsmRegisterBnd, op1: AsmRegisterBnd, ) -> Result<(), IcedError>

impl CodeAsmBndstx<AsmMemoryOperand, AsmRegisterBnd> for CodeAssembler

fn bndstx( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterBnd, ) -> Result<(), IcedError>

impl CodeAsmBound<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn bound( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBound<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn bound( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBsf<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn bsf( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBsf<AsmRegister16, AsmRegister16> for CodeAssembler

fn bsf( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBsf<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn bsf( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBsf<AsmRegister32, AsmRegister32> for CodeAssembler

fn bsf( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBsf<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn bsf( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBsf<AsmRegister64, AsmRegister64> for CodeAssembler

fn bsf( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBsr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn bsr( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBsr<AsmRegister16, AsmRegister16> for CodeAssembler

fn bsr( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn bsr( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBsr<AsmRegister32, AsmRegister32> for CodeAssembler

fn bsr( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn bsr( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmBsr<AsmRegister64, AsmRegister64> for CodeAssembler

fn bsr( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBswap<AsmRegister16> for CodeAssembler

fn bswap(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmBswap<AsmRegister32> for CodeAssembler

fn bswap(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmBswap<AsmRegister64> for CodeAssembler

fn bswap(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn bt( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn bt( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn bt( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, i32> for CodeAssembler

fn bt(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmBt<AsmMemoryOperand, u32> for CodeAssembler

fn bt(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmBt<AsmRegister16, AsmRegister16> for CodeAssembler

fn bt( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBt<AsmRegister16, i32> for CodeAssembler

fn bt(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmBt<AsmRegister16, u32> for CodeAssembler

fn bt(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmBt<AsmRegister32, AsmRegister32> for CodeAssembler

fn bt( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBt<AsmRegister32, i32> for CodeAssembler

fn bt(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmBt<AsmRegister32, u32> for CodeAssembler

fn bt(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmBt<AsmRegister64, AsmRegister64> for CodeAssembler

fn bt( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBt<AsmRegister64, i32> for CodeAssembler

fn bt(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmBt<AsmRegister64, u32> for CodeAssembler

fn bt(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn btc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn btc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn btc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, i32> for CodeAssembler

fn btc(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmMemoryOperand, u32> for CodeAssembler

fn btc(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmRegister16, AsmRegister16> for CodeAssembler

fn btc( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBtc<AsmRegister16, i32> for CodeAssembler

fn btc(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmRegister16, u32> for CodeAssembler

fn btc(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmRegister32, AsmRegister32> for CodeAssembler

fn btc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBtc<AsmRegister32, i32> for CodeAssembler

fn btc(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmRegister32, u32> for CodeAssembler

fn btc(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmRegister64, AsmRegister64> for CodeAssembler

fn btc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBtc<AsmRegister64, i32> for CodeAssembler

fn btc(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtc<AsmRegister64, u32> for CodeAssembler

fn btc(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn btr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn btr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn btr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, i32> for CodeAssembler

fn btr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmMemoryOperand, u32> for CodeAssembler

fn btr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmRegister16, AsmRegister16> for CodeAssembler

fn btr( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBtr<AsmRegister16, i32> for CodeAssembler

fn btr(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmRegister16, u32> for CodeAssembler

fn btr(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmRegister32, AsmRegister32> for CodeAssembler

fn btr( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBtr<AsmRegister32, i32> for CodeAssembler

fn btr(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmRegister32, u32> for CodeAssembler

fn btr(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmRegister64, AsmRegister64> for CodeAssembler

fn btr( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBtr<AsmRegister64, i32> for CodeAssembler

fn btr(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmBtr<AsmRegister64, u32> for CodeAssembler

fn btr(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn bts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn bts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn bts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, i32> for CodeAssembler

fn bts(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmBts<AsmMemoryOperand, u32> for CodeAssembler

fn bts(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmBts<AsmRegister16, AsmRegister16> for CodeAssembler

fn bts( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmBts<AsmRegister16, i32> for CodeAssembler

fn bts(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmBts<AsmRegister16, u32> for CodeAssembler

fn bts(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmBts<AsmRegister32, AsmRegister32> for CodeAssembler

fn bts( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBts<AsmRegister32, i32> for CodeAssembler

fn bts(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmBts<AsmRegister32, u32> for CodeAssembler

fn bts(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmBts<AsmRegister64, AsmRegister64> for CodeAssembler

fn bts( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBts<AsmRegister64, i32> for CodeAssembler

fn bts(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmBts<AsmRegister64, u32> for CodeAssembler

fn bts(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmBzhi<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn bzhi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBzhi<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

fn bzhi( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmBzhi<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn bzhi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmBzhi<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

fn bzhi( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCall<AsmMemoryOperand> for CodeAssembler

fn call(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmCall<AsmRegister16> for CodeAssembler

fn call(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmCall<AsmRegister32> for CodeAssembler

fn call(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmCall<AsmRegister64> for CodeAssembler

fn call(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmCall<CodeLabel> for CodeAssembler

fn call(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmCall<u64> for CodeAssembler

fn call(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmCbw for CodeAssembler

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

impl CodeAsmCcs_encrypt for CodeAssembler

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

impl CodeAsmCcs_hash for CodeAssembler

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

impl CodeAsmCdq for CodeAssembler

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

impl CodeAsmCdqe for CodeAssembler

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

impl CodeAsmCl1invmb for CodeAssembler

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

impl CodeAsmClac for CodeAssembler

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

impl CodeAsmClc for CodeAssembler

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

impl CodeAsmCld for CodeAssembler

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

impl CodeAsmCldemote<AsmMemoryOperand> for CodeAssembler

fn cldemote(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmClflush<AsmMemoryOperand> for CodeAssembler

fn clflush(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmClflushopt<AsmMemoryOperand> for CodeAssembler

fn clflushopt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmClgi for CodeAssembler

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

impl CodeAsmCli for CodeAssembler

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

impl CodeAsmClrssbsy<AsmMemoryOperand> for CodeAssembler

fn clrssbsy(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmClts for CodeAssembler

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

impl CodeAsmClui for CodeAssembler

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

impl CodeAsmClwb<AsmMemoryOperand> for CodeAssembler

fn clwb(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmClzero for CodeAssembler

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

impl CodeAsmCmc for CodeAssembler

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

impl CodeAsmCmova<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmova( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmova<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmova( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmova<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmova( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmova<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmova( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmova<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmova( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmova<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmova( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovae( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovae<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovae( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovae( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovae<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovae( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovae( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovae<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovae( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovb( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovb<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovb( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovb( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovb<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovb( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovb( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovb<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovb( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovbe( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovbe<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovbe( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovbe( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovbe<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovbe( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovbe( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovbe<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovbe( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovc( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovc<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovc( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovc( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovc<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovc( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovc<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmove<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmove( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmove<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmove( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmove<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmove( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmove<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmove( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmove<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmove( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmove<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmove( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovg<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovg( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovg<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovg( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovg<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovg( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovg<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovg( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovg<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovg( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovg<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovg( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovge( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovge<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovge( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovge( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovge<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovge( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovge( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovge<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovge( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovl( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovl<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovl( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovl( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovl<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovl( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovl( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovl<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovl( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovle( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovle<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovle( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovle( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovle<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovle( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovle( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovle<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovle( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovna<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovna( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovna<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovna( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovna<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovna( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovna<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovna( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovna<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovna( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovna<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovna( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovnae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnae( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnae<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovnae( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovnae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnae( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnae<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovnae( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovnae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnae( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnae<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovnae( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovnb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnb( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnb<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovnb( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovnb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnb( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnb<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovnb( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovnb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnb( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnb<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovnb( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovnbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnbe( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnbe<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovnbe( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovnbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnbe( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnbe<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovnbe( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovnbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnbe( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnbe<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovnbe( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovnc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnc( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnc<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovnc( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovnc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnc( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnc<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovnc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovnc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnc( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnc<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovnc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovne<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovne( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovne<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovne( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovne<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovne( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovne<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovne( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovne<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovne( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovne<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovne( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovng<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovng( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovng<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovng( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovng<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovng( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovng<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovng( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovng<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovng( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovng<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovng( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovnge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnge( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnge<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovnge( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovnge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnge( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnge<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovnge( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovnge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnge( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnge<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovnge( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovnl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnl( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnl<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovnl( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovnl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnl( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnl<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovnl( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovnl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnl( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnl<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovnl( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovnle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnle( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnle<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovnle( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovnle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnle( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnle<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovnle( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovnle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnle( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnle<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovnle( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovno<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovno( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovno<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovno( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovno<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovno( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovno<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovno( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovno<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovno( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovno<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovno( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovnp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnp( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnp<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovnp( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovnp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnp( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnp<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovnp( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovnp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnp( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnp<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovnp( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovns<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovns( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovns<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovns( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovns<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovns( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovns<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovns( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovns<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovns( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovns<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovns( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovnz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovnz( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnz<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovnz( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovnz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovnz( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnz<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovnz( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovnz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovnz( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovnz<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovnz( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovo( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovo<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovo( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovo( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovo<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovo( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovo( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovo<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovo( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovp( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovp<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovp( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovp( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovp<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovp( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovp( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovp<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovp( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovpe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovpe( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovpe<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovpe( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovpe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovpe( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovpe<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovpe( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovpe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovpe( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovpe<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovpe( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovpo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovpo( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovpo<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovpo( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovpo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovpo( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovpo<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovpo( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovpo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovpo( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovpo<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovpo( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovs( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovs<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovs( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovs( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovs<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovs( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovs( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovs<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovs( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmovz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmovz( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovz<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmovz( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmovz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmovz( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovz<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmovz( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmovz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmovz( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmovz<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmovz( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn cmp( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn cmp( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn cmp( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn cmp( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, i32> for CodeAssembler

fn cmp(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmMemoryOperand, u32> for CodeAssembler

fn cmp(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn cmp( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmp( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister16, i32> for CodeAssembler

fn cmp(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister16, u32> for CodeAssembler

fn cmp(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cmp( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmp( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister32, i32> for CodeAssembler

fn cmp(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister32, u32> for CodeAssembler

fn cmp(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cmp( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmp( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister64, i32> for CodeAssembler

fn cmp(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn cmp( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister8, AsmRegister8> for CodeAssembler

fn cmp(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister8, i32> for CodeAssembler

fn cmp(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmCmp<AsmRegister8, u32> for CodeAssembler

fn cmp(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmCmpbexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpbexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpbexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpbexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpbxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpbxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpbxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpbxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpcxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpcxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpcxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpcxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpeqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpeqpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpeqpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpeqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpeqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpeqps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpeqps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpeqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpeqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpeqsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpeqsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpeqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpeqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpeqss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpeqss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpeqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmplepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmplepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmplepd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmplepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpleps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpleps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmplesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmplesd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmplesd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmplesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpless( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpless<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmplexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmplexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmplexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmplexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpltpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpltpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpltps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpltps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpltsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpltsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpltss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpltss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmplxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmplxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmplxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmplxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnaexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnaexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnaexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnaexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnaxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnaxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnaxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnaxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnbexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnbexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnbexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnbexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnbxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnbxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnbxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnbxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpncxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpncxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpncxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpncxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpneqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpneqpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpneqpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpneqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpneqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpneqps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpneqps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpneqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpneqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpneqsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpneqsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpneqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpneqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpneqss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpneqss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpneqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpngexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpngexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpngexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpngexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpngxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpngxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpngxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpngxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnlepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnlepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpnlepd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpnlepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpnleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnleps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpnleps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpnleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpnlesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnlesd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpnlesd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpnlesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpnless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnless( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpnless<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpnless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpnlexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnlexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnlexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnlexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnltpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpnltpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpnltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpnltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnltps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpnltps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpnltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpnltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnltsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpnltsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpnltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpnltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpnltss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpnltss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpnltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpnlxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnlxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnlxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnlxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnoxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnoxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnoxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnpxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnpxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnpxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnpxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnsxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnsxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnsxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnsxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpnzxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpnzxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpnzxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpnzxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpordpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpordpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpordps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpordps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpordsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpordsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpordss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpordss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpoxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpoxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpoxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn cmppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn cmppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmCmppd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn cmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmCmppd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn cmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmCmppexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmppexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmppexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmppexadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmppoxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmppoxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmppoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmppoxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn cmpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn cmpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmCmpps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn cmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmCmpps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn cmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmCmppxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmppxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmppxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmppxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpsb for CodeAssembler

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

impl CodeAsmCmpsd for CodeAssembler

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

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn cmpsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn cmpsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn cmpsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn cmpsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmCmpsq for CodeAssembler

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

impl CodeAsmCmpss<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn cmpss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmCmpss<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn cmpss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmCmpss<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn cmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmCmpss<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn cmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmCmpsw for CodeAssembler

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

impl CodeAsmCmpsxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpsxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpsxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpsxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpunordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpunordpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpunordpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpunordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpunordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpunordps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpunordps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpunordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpunordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpunordsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpunordsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpunordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpunordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cmpunordss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCmpunordss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cmpunordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn cmpxchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn cmpxchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn cmpxchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn cmpxchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmRegister16, AsmRegister16> for CodeAssembler

fn cmpxchg( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpxchg( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpxchg( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCmpxchg<AsmRegister8, AsmRegister8> for CodeAssembler

fn cmpxchg( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmCmpxchg16b<AsmMemoryOperand> for CodeAssembler

fn cmpxchg16b(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmCmpxchg8b<AsmMemoryOperand> for CodeAssembler

fn cmpxchg8b(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmCmpzxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

fn cmpzxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCmpzxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

fn cmpzxadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmComisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn comisd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmComisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn comisd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmComiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn comiss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmComiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn comiss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCpu_read for CodeAssembler

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

impl CodeAsmCpu_write for CodeAssembler

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

impl CodeAsmCpuid for CodeAssembler

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

impl CodeAsmCqo for CodeAssembler

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

impl CodeAsmCrc32<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn crc32( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCrc32<AsmRegister32, AsmRegister16> for CodeAssembler

fn crc32( &mut self, op0: AsmRegister32, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmCrc32<AsmRegister32, AsmRegister32> for CodeAssembler

fn crc32( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCrc32<AsmRegister32, AsmRegister8> for CodeAssembler

fn crc32( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmCrc32<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn crc32( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCrc32<AsmRegister64, AsmRegister64> for CodeAssembler

fn crc32( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCrc32<AsmRegister64, AsmRegister8> for CodeAssembler

fn crc32( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmCvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtdq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtdq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvtdq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtdq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtdq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtdq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvtdq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvtpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn cvtpd2pi( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtpd2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

fn cvtpd2pi( &mut self, op0: AsmRegisterMm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtpd2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtpd2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtpd2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvtpd2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtpi2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtpi2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtpi2pd<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

fn cvtpi2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmCvtpi2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtpi2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtpi2ps<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

fn cvtpi2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmCvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvtps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtps2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtps2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvtps2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn cvtps2pi( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtps2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

fn cvtps2pi( &mut self, op0: AsmRegisterMm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cvtsd2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn cvtsd2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cvtsd2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn cvtsd2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtsd2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtsd2ss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtsd2ss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvtsd2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn cvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn cvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn cvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn cvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmCvtss2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvtss2sd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtss2sd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvtss2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cvtss2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn cvtss2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cvtss2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvtss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn cvtss2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvttpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvttpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvttpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvttpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn cvttpd2pi( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvttpd2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

fn cvttpd2pi( &mut self, op0: AsmRegisterMm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn cvttps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvttps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn cvttps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvttps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn cvttps2pi( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvttps2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

fn cvttps2pi( &mut self, op0: AsmRegisterMm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cvttsd2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvttsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn cvttsd2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cvttsd2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvttsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn cvttsd2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn cvttss2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvttss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn cvttss2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn cvttss2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmCvttss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn cvttss2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmCwd for CodeAssembler

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

impl CodeAsmCwde for CodeAssembler

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

impl CodeAsmDaa for CodeAssembler

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

impl CodeAsmDas for CodeAssembler

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

impl CodeAsmDec<AsmMemoryOperand> for CodeAssembler

fn dec(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmDec<AsmRegister16> for CodeAssembler

fn dec(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmDec<AsmRegister32> for CodeAssembler

fn dec(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmDec<AsmRegister64> for CodeAssembler

fn dec(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmDec<AsmRegister8> for CodeAssembler

fn dec(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmDiv<AsmMemoryOperand> for CodeAssembler

fn div(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmDiv<AsmRegister16> for CodeAssembler

fn div(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmDiv<AsmRegister32> for CodeAssembler

fn div(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmDiv<AsmRegister64> for CodeAssembler

fn div(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmDiv<AsmRegister8> for CodeAssembler

fn div(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmDivpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn divpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmDivpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn divpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmDivps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn divps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmDivps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn divps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmDivsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn divsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmDivsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn divsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmDivss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn divss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmDivss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn divss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmDmint for CodeAssembler

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

impl CodeAsmDppd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn dppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmDppd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn dppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmDppd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn dppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmDppd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn dppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmDpps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn dpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmDpps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn dpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmDpps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn dpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmDpps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn dpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmEmms for CodeAssembler

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

impl CodeAsmEncls for CodeAssembler

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

impl CodeAsmEnclu for CodeAssembler

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

impl CodeAsmEnclv for CodeAssembler

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

impl CodeAsmEncodekey128<AsmRegister32, AsmRegister32> for CodeAssembler

fn encodekey128( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmEncodekey256<AsmRegister32, AsmRegister32> for CodeAssembler

fn encodekey256( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmEndbr32 for CodeAssembler

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

impl CodeAsmEndbr64 for CodeAssembler

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

impl CodeAsmEnqcmd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn enqcmd( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmEnqcmd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn enqcmd( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmEnqcmd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn enqcmd( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmEnqcmds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn enqcmds( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmEnqcmds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn enqcmds( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmEnqcmds<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn enqcmds( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmEnter<i32, i32> for CodeAssembler

fn enter(&mut self, op0: i32, op1: i32) -> Result<(), IcedError>

impl CodeAsmEnter<u32, u32> for CodeAssembler

fn enter(&mut self, op0: u32, op1: u32) -> Result<(), IcedError>

impl CodeAsmErets for CodeAssembler

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

impl CodeAsmEretu for CodeAssembler

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

impl CodeAsmExtractps<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn extractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmExtractps<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn extractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmExtractps<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn extractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmExtractps<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn extractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmExtractps<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn extractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmExtractps<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn extractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmExtrq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn extrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmExtrq3<AsmRegisterXmm, i32, i32> for CodeAssembler

fn extrq_3( &mut self, op0: AsmRegisterXmm, op1: i32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmExtrq3<AsmRegisterXmm, u32, u32> for CodeAssembler

fn extrq_3( &mut self, op0: AsmRegisterXmm, op1: u32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmF2xm1 for CodeAssembler

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

impl CodeAsmFabs for CodeAssembler

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

impl CodeAsmFadd<AsmMemoryOperand> for CodeAssembler

fn fadd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFadd2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fadd_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFaddp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn faddp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFbld<AsmMemoryOperand> for CodeAssembler

fn fbld(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFbstp<AsmMemoryOperand> for CodeAssembler

fn fbstp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFchs for CodeAssembler

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

impl CodeAsmFclex for CodeAssembler

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

impl CodeAsmFcmovb<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcmovb( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcmovbe<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcmovbe( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcmove<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcmove( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcmovnb<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcmovnb( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcmovnbe<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcmovnbe( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcmovne<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcmovne( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcmovnu<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcmovnu( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcmovu<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcmovu( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcom<AsmMemoryOperand> for CodeAssembler

fn fcom(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFcom2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcom_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcomi<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcomi( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcomip<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcomip( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcomp<AsmMemoryOperand> for CodeAssembler

fn fcomp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFcomp2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fcomp_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFcompp for CodeAssembler

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

impl CodeAsmFcos for CodeAssembler

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

impl CodeAsmFdecstp for CodeAssembler

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

impl CodeAsmFdisi for CodeAssembler

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

impl CodeAsmFdiv<AsmMemoryOperand> for CodeAssembler

fn fdiv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFdiv2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fdiv_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFdivp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fdivp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFdivr<AsmMemoryOperand> for CodeAssembler

fn fdivr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFdivr2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fdivr_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFdivrp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fdivrp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFemms for CodeAssembler

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

impl CodeAsmFeni for CodeAssembler

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

impl CodeAsmFfree<AsmRegisterSt> for CodeAssembler

fn ffree(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

impl CodeAsmFfreep<AsmRegisterSt> for CodeAssembler

fn ffreep(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

impl CodeAsmFiadd<AsmMemoryOperand> for CodeAssembler

fn fiadd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFicom<AsmMemoryOperand> for CodeAssembler

fn ficom(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFicomp<AsmMemoryOperand> for CodeAssembler

fn ficomp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFidiv<AsmMemoryOperand> for CodeAssembler

fn fidiv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFidivr<AsmMemoryOperand> for CodeAssembler

fn fidivr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFild<AsmMemoryOperand> for CodeAssembler

fn fild(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFimul<AsmMemoryOperand> for CodeAssembler

fn fimul(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFincstp for CodeAssembler

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

impl CodeAsmFinit for CodeAssembler

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

impl CodeAsmFist<AsmMemoryOperand> for CodeAssembler

fn fist(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFistp<AsmMemoryOperand> for CodeAssembler

fn fistp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFisttp<AsmMemoryOperand> for CodeAssembler

fn fisttp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFisub<AsmMemoryOperand> for CodeAssembler

fn fisub(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFisubr<AsmMemoryOperand> for CodeAssembler

fn fisubr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFld<AsmMemoryOperand> for CodeAssembler

fn fld(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFld<AsmRegisterSt> for CodeAssembler

fn fld(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

impl CodeAsmFld1 for CodeAssembler

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

impl CodeAsmFldcw<AsmMemoryOperand> for CodeAssembler

fn fldcw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFldenv<AsmMemoryOperand> for CodeAssembler

fn fldenv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFldl2e for CodeAssembler

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

impl CodeAsmFldl2t for CodeAssembler

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

impl CodeAsmFldlg2 for CodeAssembler

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

impl CodeAsmFldln2 for CodeAssembler

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

impl CodeAsmFldpi for CodeAssembler

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

impl CodeAsmFldz for CodeAssembler

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

impl CodeAsmFmul<AsmMemoryOperand> for CodeAssembler

fn fmul(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFmul2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fmul_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFmulp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fmulp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFnclex for CodeAssembler

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

impl CodeAsmFndisi for CodeAssembler

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

impl CodeAsmFneni for CodeAssembler

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

impl CodeAsmFninit for CodeAssembler

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

impl CodeAsmFnop for CodeAssembler

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

impl CodeAsmFnsave<AsmMemoryOperand> for CodeAssembler

fn fnsave(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFnsetpm for CodeAssembler

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

impl CodeAsmFnstcw<AsmMemoryOperand> for CodeAssembler

fn fnstcw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFnstdw<AsmRegister16> for CodeAssembler

fn fnstdw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFnstenv<AsmMemoryOperand> for CodeAssembler

fn fnstenv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFnstsg<AsmRegister16> for CodeAssembler

fn fnstsg(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFnstsw<AsmMemoryOperand> for CodeAssembler

fn fnstsw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFnstsw<AsmRegister16> for CodeAssembler

fn fnstsw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFpatan for CodeAssembler

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

impl CodeAsmFprem for CodeAssembler

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

impl CodeAsmFprem1 for CodeAssembler

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

impl CodeAsmFptan for CodeAssembler

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

impl CodeAsmFrndint for CodeAssembler

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

impl CodeAsmFrstor<AsmMemoryOperand> for CodeAssembler

fn frstor(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFrstpm for CodeAssembler

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

impl CodeAsmFsave<AsmMemoryOperand> for CodeAssembler

fn fsave(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFscale for CodeAssembler

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

impl CodeAsmFsetpm for CodeAssembler

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

impl CodeAsmFsin for CodeAssembler

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

impl CodeAsmFsincos for CodeAssembler

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

impl CodeAsmFsqrt for CodeAssembler

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

impl CodeAsmFst<AsmMemoryOperand> for CodeAssembler

fn fst(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFst<AsmRegisterSt> for CodeAssembler

fn fst(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

impl CodeAsmFstcw<AsmMemoryOperand> for CodeAssembler

fn fstcw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFstdw<AsmRegister16> for CodeAssembler

fn fstdw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFstenv<AsmMemoryOperand> for CodeAssembler

fn fstenv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFstp<AsmMemoryOperand> for CodeAssembler

fn fstp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFstp<AsmRegisterSt> for CodeAssembler

fn fstp(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

impl CodeAsmFstpnce<AsmRegisterSt> for CodeAssembler

fn fstpnce(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

impl CodeAsmFstsg<AsmRegister16> for CodeAssembler

fn fstsg(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFstsw<AsmMemoryOperand> for CodeAssembler

fn fstsw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFstsw<AsmRegister16> for CodeAssembler

fn fstsw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmFsub<AsmMemoryOperand> for CodeAssembler

fn fsub(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFsub2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fsub_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFsubp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fsubp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFsubr<AsmMemoryOperand> for CodeAssembler

fn fsubr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFsubr2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fsubr_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFsubrp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fsubrp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFtst for CodeAssembler

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

impl CodeAsmFucom<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fucom( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFucomi<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fucomi( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFucomip<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fucomip( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFucomp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fucomp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFucompp for CodeAssembler

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

impl CodeAsmFxam for CodeAssembler

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

impl CodeAsmFxch<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

fn fxch( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

impl CodeAsmFxrstor<AsmMemoryOperand> for CodeAssembler

fn fxrstor(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFxrstor64<AsmMemoryOperand> for CodeAssembler

fn fxrstor64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFxsave<AsmMemoryOperand> for CodeAssembler

fn fxsave(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFxsave64<AsmMemoryOperand> for CodeAssembler

fn fxsave64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmFxtract for CodeAssembler

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

impl CodeAsmFyl2x for CodeAssembler

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

impl CodeAsmFyl2xp1 for CodeAssembler

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

impl CodeAsmGetsec for CodeAssembler

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

impl CodeAsmGetsecq for CodeAssembler

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

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn gf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn gf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn gf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn gf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn gf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn gf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn gf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn gf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmGf2p8mulb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn gf2p8mulb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmGf2p8mulb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn gf2p8mulb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmHaddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn haddpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmHaddpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn haddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmHaddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn haddps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmHaddps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn haddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmHlt for CodeAssembler

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

impl CodeAsmHreset<i32> for CodeAssembler

fn hreset(&mut self, op0: i32) -> Result<(), IcedError>

impl CodeAsmHreset<u32> for CodeAssembler

fn hreset(&mut self, op0: u32) -> Result<(), IcedError>

impl CodeAsmHsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn hsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmHsubpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn hsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmHsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn hsubps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmHsubps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn hsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn ibts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn ibts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmIbts<AsmRegister16, AsmRegister16> for CodeAssembler

fn ibts( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmIbts<AsmRegister32, AsmRegister32> for CodeAssembler

fn ibts( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmIdiv<AsmMemoryOperand> for CodeAssembler

fn idiv(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmIdiv<AsmRegister16> for CodeAssembler

fn idiv(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmIdiv<AsmRegister32> for CodeAssembler

fn idiv(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmIdiv<AsmRegister64> for CodeAssembler

fn idiv(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmIdiv<AsmRegister8> for CodeAssembler

fn idiv(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmImul<AsmMemoryOperand> for CodeAssembler

fn imul(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmImul<AsmRegister16> for CodeAssembler

fn imul(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmImul<AsmRegister32> for CodeAssembler

fn imul(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmImul<AsmRegister64> for CodeAssembler

fn imul(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmImul<AsmRegister8> for CodeAssembler

fn imul(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmImul2<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn imul_2( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmImul2<AsmRegister16, AsmRegister16> for CodeAssembler

fn imul_2( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmImul2<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn imul_2( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmImul2<AsmRegister32, AsmRegister32> for CodeAssembler

fn imul_2( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmImul2<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn imul_2( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmImul2<AsmRegister64, AsmRegister64> for CodeAssembler

fn imul_2( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, i32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, u32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister16, AsmRegister16, i32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister16, AsmRegister16, u32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister32, AsmRegister32, i32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister32, AsmRegister32, u32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmImul3<AsmRegister64, AsmRegister64, i32> for CodeAssembler

fn imul_3( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmIn<AsmRegister16, AsmRegister16> for CodeAssembler

fn in_( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmIn<AsmRegister16, i32> for CodeAssembler

fn in_(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmIn<AsmRegister16, u32> for CodeAssembler

fn in_(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmIn<AsmRegister32, AsmRegister16> for CodeAssembler

fn in_( &mut self, op0: AsmRegister32, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmIn<AsmRegister32, i32> for CodeAssembler

fn in_(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmIn<AsmRegister32, u32> for CodeAssembler

fn in_(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmIn<AsmRegister8, AsmRegister16> for CodeAssembler

fn in_( &mut self, op0: AsmRegister8, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmIn<AsmRegister8, i32> for CodeAssembler

fn in_(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmIn<AsmRegister8, u32> for CodeAssembler

fn in_(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmInc<AsmMemoryOperand> for CodeAssembler

fn inc(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmInc<AsmRegister16> for CodeAssembler

fn inc(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmInc<AsmRegister32> for CodeAssembler

fn inc(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmInc<AsmRegister64> for CodeAssembler

fn inc(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmInc<AsmRegister8> for CodeAssembler

fn inc(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmIncsspd<AsmRegister32> for CodeAssembler

fn incsspd(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmIncsspq<AsmRegister64> for CodeAssembler

fn incsspq(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmInsb for CodeAssembler

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

impl CodeAsmInsd for CodeAssembler

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

impl CodeAsmInsertps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn insertps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmInsertps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn insertps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmInsertps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn insertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmInsertps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn insertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmInsertq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn insertq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmInsertq4<AsmRegisterXmm, AsmRegisterXmm, i32, i32> for CodeAssembler

fn insertq_4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmInsertq4<AsmRegisterXmm, AsmRegisterXmm, u32, u32> for CodeAssembler

fn insertq_4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmInsw for CodeAssembler

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

impl CodeAsmInt<i32> for CodeAssembler

fn int(&mut self, op0: i32) -> Result<(), IcedError>

impl CodeAsmInt<u32> for CodeAssembler

fn int(&mut self, op0: u32) -> Result<(), IcedError>

impl CodeAsmInt1 for CodeAssembler

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

impl CodeAsmInt3 for CodeAssembler

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

impl CodeAsmInto for CodeAssembler

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

impl CodeAsmInvd for CodeAssembler

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

impl CodeAsmInvept<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn invept( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmInvept<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn invept( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmInvlpg<AsmMemoryOperand> for CodeAssembler

fn invlpg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmInvlpga for CodeAssembler

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

impl CodeAsmInvlpgb for CodeAssembler

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

impl CodeAsmInvpcid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn invpcid( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmInvpcid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn invpcid( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmInvvpid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn invvpid( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmInvvpid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn invvpid( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmIret for CodeAssembler

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

impl CodeAsmIretd for CodeAssembler

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

impl CodeAsmIretq for CodeAssembler

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

impl CodeAsmJa<CodeLabel> for CodeAssembler

fn ja(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJa<u64> for CodeAssembler

fn ja(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJae<CodeLabel> for CodeAssembler

fn jae(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJae<u64> for CodeAssembler

fn jae(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJb<CodeLabel> for CodeAssembler

fn jb(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJb<u64> for CodeAssembler

fn jb(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJbe<CodeLabel> for CodeAssembler

fn jbe(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJbe<u64> for CodeAssembler

fn jbe(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJc<CodeLabel> for CodeAssembler

fn jc(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJc<u64> for CodeAssembler

fn jc(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJcxz<CodeLabel> for CodeAssembler

fn jcxz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJcxz<u64> for CodeAssembler

fn jcxz(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJe<CodeLabel> for CodeAssembler

fn je(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJe<u64> for CodeAssembler

fn je(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJecxz<CodeLabel> for CodeAssembler

fn jecxz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJecxz<u64> for CodeAssembler

fn jecxz(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJg<CodeLabel> for CodeAssembler

fn jg(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJg<u64> for CodeAssembler

fn jg(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJge<CodeLabel> for CodeAssembler

fn jge(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJge<u64> for CodeAssembler

fn jge(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJl<CodeLabel> for CodeAssembler

fn jl(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJl<u64> for CodeAssembler

fn jl(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJle<CodeLabel> for CodeAssembler

fn jle(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJle<u64> for CodeAssembler

fn jle(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJmp<AsmMemoryOperand> for CodeAssembler

fn jmp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmJmp<AsmRegister16> for CodeAssembler

fn jmp(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmJmp<AsmRegister32> for CodeAssembler

fn jmp(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmJmp<AsmRegister64> for CodeAssembler

fn jmp(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmJmp<CodeLabel> for CodeAssembler

fn jmp(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJmp<u64> for CodeAssembler

fn jmp(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJmpe<AsmMemoryOperand> for CodeAssembler

fn jmpe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmJmpe<AsmRegister16> for CodeAssembler

fn jmpe(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmJmpe<AsmRegister32> for CodeAssembler

fn jmpe(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmJmpe<CodeLabel> for CodeAssembler

fn jmpe(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJmpe<u64> for CodeAssembler

fn jmpe(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJna<CodeLabel> for CodeAssembler

fn jna(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJna<u64> for CodeAssembler

fn jna(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJnae<CodeLabel> for CodeAssembler

fn jnae(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJnae<u64> for CodeAssembler

fn jnae(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJnb<CodeLabel> for CodeAssembler

fn jnb(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJnb<u64> for CodeAssembler

fn jnb(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJnbe<CodeLabel> for CodeAssembler

fn jnbe(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJnbe<u64> for CodeAssembler

fn jnbe(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJnc<CodeLabel> for CodeAssembler

fn jnc(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJnc<u64> for CodeAssembler

fn jnc(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJne<CodeLabel> for CodeAssembler

fn jne(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJne<u64> for CodeAssembler

fn jne(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJng<CodeLabel> for CodeAssembler

fn jng(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJng<u64> for CodeAssembler

fn jng(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJnge<CodeLabel> for CodeAssembler

fn jnge(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJnge<u64> for CodeAssembler

fn jnge(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJnl<CodeLabel> for CodeAssembler

fn jnl(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJnl<u64> for CodeAssembler

fn jnl(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJnle<CodeLabel> for CodeAssembler

fn jnle(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJnle<u64> for CodeAssembler

fn jnle(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJno<CodeLabel> for CodeAssembler

fn jno(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJno<u64> for CodeAssembler

fn jno(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJnp<CodeLabel> for CodeAssembler

fn jnp(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJnp<u64> for CodeAssembler

fn jnp(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJns<CodeLabel> for CodeAssembler

fn jns(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJns<u64> for CodeAssembler

fn jns(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJnz<CodeLabel> for CodeAssembler

fn jnz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJnz<u64> for CodeAssembler

fn jnz(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJo<CodeLabel> for CodeAssembler

fn jo(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJo<u64> for CodeAssembler

fn jo(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJp<CodeLabel> for CodeAssembler

fn jp(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJp<u64> for CodeAssembler

fn jp(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJpe<CodeLabel> for CodeAssembler

fn jpe(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJpe<u64> for CodeAssembler

fn jpe(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJpo<CodeLabel> for CodeAssembler

fn jpo(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJpo<u64> for CodeAssembler

fn jpo(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJrcxz<CodeLabel> for CodeAssembler

fn jrcxz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJrcxz<u64> for CodeAssembler

fn jrcxz(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJs<CodeLabel> for CodeAssembler

fn js(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJs<u64> for CodeAssembler

fn js(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmJz<CodeLabel> for CodeAssembler

fn jz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmJz<u64> for CodeAssembler

fn jz(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmKaddb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kaddb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKaddd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kaddd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKaddq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kaddq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKaddw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kaddw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKandb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kandb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKandd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kandd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKandnb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kandnb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKandnd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kandnd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKandnq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kandnq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKandnw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kandnw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKandq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kandq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKandw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kandw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovb<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

fn kmovb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovb<AsmRegister32, AsmRegisterK> for CodeAssembler

fn kmovb( &mut self, op0: AsmRegister32, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovb<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

fn kmovb( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmKmovb<AsmRegisterK, AsmRegister32> for CodeAssembler

fn kmovb( &mut self, op0: AsmRegisterK, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmKmovb<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kmovb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovd<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

fn kmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovd<AsmRegister32, AsmRegisterK> for CodeAssembler

fn kmovd( &mut self, op0: AsmRegister32, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovd<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

fn kmovd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmKmovd<AsmRegisterK, AsmRegister32> for CodeAssembler

fn kmovd( &mut self, op0: AsmRegisterK, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmKmovd<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kmovd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovq<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

fn kmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovq<AsmRegister64, AsmRegisterK> for CodeAssembler

fn kmovq( &mut self, op0: AsmRegister64, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovq<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

fn kmovq( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmKmovq<AsmRegisterK, AsmRegister64> for CodeAssembler

fn kmovq( &mut self, op0: AsmRegisterK, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmKmovq<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kmovq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovw<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

fn kmovw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovw<AsmRegister32, AsmRegisterK> for CodeAssembler

fn kmovw( &mut self, op0: AsmRegister32, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKmovw<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

fn kmovw( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmKmovw<AsmRegisterK, AsmRegister32> for CodeAssembler

fn kmovw( &mut self, op0: AsmRegisterK, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmKmovw<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kmovw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKnotb<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn knotb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKnotd<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn knotd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKnotq<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn knotq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKnotw<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn knotw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKorb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn korb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKord<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kord( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKorq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn korq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKortestb<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kortestb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKortestd<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kortestd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKortestq<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kortestq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKortestw<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kortestw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKorw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn korw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKshiftlb<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

fn kshiftlb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmKshiftlb<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

fn kshiftlb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmKshiftld<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

fn kshiftld( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmKshiftld<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

fn kshiftld( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmKshiftlq<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

fn kshiftlq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmKshiftlq<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

fn kshiftlq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmKshiftlw<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

fn kshiftlw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmKshiftlw<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

fn kshiftlw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmKshiftrb<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

fn kshiftrb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmKshiftrb<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

fn kshiftrb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmKshiftrd<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

fn kshiftrd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmKshiftrd<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

fn kshiftrd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmKshiftrq<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

fn kshiftrq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmKshiftrq<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

fn kshiftrq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmKshiftrw<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

fn kshiftrw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmKshiftrw<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

fn kshiftrw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmKtestb<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn ktestb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKtestd<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn ktestd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKtestq<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn ktestq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKtestw<AsmRegisterK, AsmRegisterK> for CodeAssembler

fn ktestw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKunpckbw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kunpckbw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKunpckdq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kunpckdq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKunpckwd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kunpckwd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKxnorb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kxnorb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKxnord<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kxnord( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKxnorq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kxnorq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKxnorw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kxnorw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKxorb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kxorb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKxord<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kxord( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKxorq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kxorq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmKxorw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

fn kxorw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmLahf for CodeAssembler

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

impl CodeAsmLar<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lar( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLar<AsmRegister16, AsmRegister16> for CodeAssembler

fn lar( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmLar<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lar( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLar<AsmRegister32, AsmRegister32> for CodeAssembler

fn lar( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmLar<AsmRegister64, AsmRegister64> for CodeAssembler

fn lar( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmLddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn lddqu( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLdmxcsr<AsmMemoryOperand> for CodeAssembler

fn ldmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lds( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lds( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLdtilecfg<AsmMemoryOperand> for CodeAssembler

fn ldtilecfg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLea<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lea( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLea<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lea( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLea<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lea( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLeave for CodeAssembler

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

impl CodeAsmLes<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn les( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLes<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn les( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLfence for CodeAssembler

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

impl CodeAsmLfs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lfs( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLfs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lfs( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLfs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lfs( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLgdt<AsmMemoryOperand> for CodeAssembler

fn lgdt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLgs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lgs( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLgs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lgs( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLgs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lgs( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLidt<AsmMemoryOperand> for CodeAssembler

fn lidt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLkgs<AsmMemoryOperand> for CodeAssembler

fn lkgs(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLkgs<AsmRegister16> for CodeAssembler

fn lkgs(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmLkgs<AsmRegister32> for CodeAssembler

fn lkgs(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmLkgs<AsmRegister64> for CodeAssembler

fn lkgs(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmLldt<AsmMemoryOperand> for CodeAssembler

fn lldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLldt<AsmRegister16> for CodeAssembler

fn lldt(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmLldt<AsmRegister32> for CodeAssembler

fn lldt(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmLldt<AsmRegister64> for CodeAssembler

fn lldt(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmLlwpcb<AsmRegister32> for CodeAssembler

fn llwpcb(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmLlwpcb<AsmRegister64> for CodeAssembler

fn llwpcb(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmLmsw<AsmMemoryOperand> for CodeAssembler

fn lmsw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLmsw<AsmRegister16> for CodeAssembler

fn lmsw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmLmsw<AsmRegister32> for CodeAssembler

fn lmsw(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmLmsw<AsmRegister64> for CodeAssembler

fn lmsw(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmLoadall for CodeAssembler

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

impl CodeAsmLoadiwkey<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn loadiwkey( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmLodsb for CodeAssembler

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

impl CodeAsmLodsd for CodeAssembler

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

impl CodeAsmLodsq for CodeAssembler

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

impl CodeAsmLodsw for CodeAssembler

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

impl CodeAsmLoop<CodeLabel> for CodeAssembler

fn loop_(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmLoop<u64> for CodeAssembler

fn loop_(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmLoope<CodeLabel> for CodeAssembler

fn loope(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmLoope<u64> for CodeAssembler

fn loope(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmLoopne<CodeLabel> for CodeAssembler

fn loopne(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmLoopne<u64> for CodeAssembler

fn loopne(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmLoopnz<CodeLabel> for CodeAssembler

fn loopnz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmLoopnz<u64> for CodeAssembler

fn loopnz(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmLoopz<CodeLabel> for CodeAssembler

fn loopz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmLoopz<u64> for CodeAssembler

fn loopz(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmLsl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lsl( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLsl<AsmRegister16, AsmRegister16> for CodeAssembler

fn lsl( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmLsl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lsl( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLsl<AsmRegister32, AsmRegister32> for CodeAssembler

fn lsl( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmLsl<AsmRegister64, AsmRegister64> for CodeAssembler

fn lsl( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmLss<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lss( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLss<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lss( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLss<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lss( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLtr<AsmMemoryOperand> for CodeAssembler

fn ltr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmLtr<AsmRegister16> for CodeAssembler

fn ltr(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmLtr<AsmRegister32> for CodeAssembler

fn ltr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmLtr<AsmRegister64> for CodeAssembler

fn ltr(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn lwpins( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn lwpins( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister32, AsmRegister32, i32> for CodeAssembler

fn lwpins( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister32, AsmRegister32, u32> for CodeAssembler

fn lwpins( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn lwpins( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

fn lwpins( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister64, AsmRegister32, i32> for CodeAssembler

fn lwpins( &mut self, op0: AsmRegister64, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmLwpins<AsmRegister64, AsmRegister32, u32> for CodeAssembler

fn lwpins( &mut self, op0: AsmRegister64, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn lwpval( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn lwpval( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister32, AsmRegister32, i32> for CodeAssembler

fn lwpval( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister32, AsmRegister32, u32> for CodeAssembler

fn lwpval( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn lwpval( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

fn lwpval( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister64, AsmRegister32, i32> for CodeAssembler

fn lwpval( &mut self, op0: AsmRegister64, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmLwpval<AsmRegister64, AsmRegister32, u32> for CodeAssembler

fn lwpval( &mut self, op0: AsmRegister64, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmLzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn lzcnt( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLzcnt<AsmRegister16, AsmRegister16> for CodeAssembler

fn lzcnt( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmLzcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn lzcnt( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLzcnt<AsmRegister32, AsmRegister32> for CodeAssembler

fn lzcnt( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmLzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn lzcnt( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmLzcnt<AsmRegister64, AsmRegister64> for CodeAssembler

fn lzcnt( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMaskmovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn maskmovdqu( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMaskmovq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn maskmovq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmMaxpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn maxpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMaxpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn maxpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMaxps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn maxps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMaxps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn maxps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn maxsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMaxsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn maxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMaxss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn maxss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMaxss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn maxss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMcommit for CodeAssembler

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

impl CodeAsmMfence for CodeAssembler

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

impl CodeAsmMinpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn minpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMinpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn minpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMinps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn minps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMinps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn minps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMinsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn minsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMinsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn minsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMinss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn minss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMinss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn minss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMonitor for CodeAssembler

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

impl CodeAsmMonitorx for CodeAssembler

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

impl CodeAsmMontmul for CodeAssembler

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

impl CodeAsmMov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn mov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn mov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn mov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn mov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, AsmRegisterSegment> for CodeAssembler

fn mov( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterSegment, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, i32> for CodeAssembler

fn mov(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmMov<AsmMemoryOperand, u32> for CodeAssembler

fn mov(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn mov( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister16, AsmRegister16> for CodeAssembler

fn mov( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister16, AsmRegisterSegment> for CodeAssembler

fn mov( &mut self, op0: AsmRegister16, op1: AsmRegisterSegment, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister16, i32> for CodeAssembler

fn mov(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister16, u32> for CodeAssembler

fn mov(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn mov( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister32, AsmRegister32> for CodeAssembler

fn mov( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister32, AsmRegisterCr> for CodeAssembler

fn mov( &mut self, op0: AsmRegister32, op1: AsmRegisterCr, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister32, AsmRegisterDr> for CodeAssembler

fn mov( &mut self, op0: AsmRegister32, op1: AsmRegisterDr, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister32, AsmRegisterSegment> for CodeAssembler

fn mov( &mut self, op0: AsmRegister32, op1: AsmRegisterSegment, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister32, AsmRegisterTr> for CodeAssembler

fn mov( &mut self, op0: AsmRegister32, op1: AsmRegisterTr, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister32, i32> for CodeAssembler

fn mov(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister32, u32> for CodeAssembler

fn mov(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn mov( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister64, AsmRegister64> for CodeAssembler

fn mov( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister64, AsmRegisterCr> for CodeAssembler

fn mov( &mut self, op0: AsmRegister64, op1: AsmRegisterCr, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister64, AsmRegisterDr> for CodeAssembler

fn mov( &mut self, op0: AsmRegister64, op1: AsmRegisterDr, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister64, AsmRegisterSegment> for CodeAssembler

fn mov( &mut self, op0: AsmRegister64, op1: AsmRegisterSegment, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister64, i64> for CodeAssembler

fn mov(&mut self, op0: AsmRegister64, op1: i64) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister64, u64> for CodeAssembler

fn mov(&mut self, op0: AsmRegister64, op1: u64) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn mov( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister8, AsmRegister8> for CodeAssembler

fn mov(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister8, i32> for CodeAssembler

fn mov(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegister8, u32> for CodeAssembler

fn mov(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterCr, AsmRegister32> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterCr, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterCr, AsmRegister64> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterCr, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterDr, AsmRegister32> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterDr, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterDr, AsmRegister64> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterDr, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterSegment, AsmMemoryOperand> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterSegment, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterSegment, AsmRegister16> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterSegment, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterSegment, AsmRegister32> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterSegment, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterSegment, AsmRegister64> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterSegment, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMov<AsmRegisterTr, AsmRegister32> for CodeAssembler

fn mov( &mut self, op0: AsmRegisterTr, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMovapd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movapd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovapd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movapd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovapd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movapd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovaps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movaps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovaps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movaps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovaps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movaps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn movbe( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn movbe( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn movbe( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movbe( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movbe( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movbe( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

fn movd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovd<AsmRegister32, AsmRegisterMm> for CodeAssembler

fn movd( &mut self, op0: AsmRegister32, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmMovd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn movd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn movd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovd<AsmRegisterMm, AsmRegister32> for CodeAssembler

fn movd( &mut self, op0: AsmRegisterMm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn movd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movddup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovddup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movddup( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovdir64b<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movdir64b( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovdir64b<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movdir64b( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovdir64b<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movdir64b( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn movdiri( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn movdiri( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMovdq2q<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

fn movdq2q( &mut self, op0: AsmRegisterMm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovdqa<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movdqa( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movdqa( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovdqa<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movdqa( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovdqu<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movdqu( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovdqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movdqu( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movdqu( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovhlps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movhlps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovhpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movhpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovhpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movhpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovhps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movhps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovhps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movhps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovlhps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movlhps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovlpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movlpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovlpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movlpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovlps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movlps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovlps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movlps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovmskpd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn movmskpd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovmskpd<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn movmskpd( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovmskps<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn movmskps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovmskps<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn movmskps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movntdqa( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn movnti( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn movnti( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovntq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

fn movntq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmMovntsd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntsd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovntss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movntss( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

fn movq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegister64, AsmRegisterMm> for CodeAssembler

fn movq( &mut self, op0: AsmRegister64, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn movq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn movq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegisterMm, AsmRegister64> for CodeAssembler

fn movq( &mut self, op0: AsmRegisterMm, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn movq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn movq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMovq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovq2dq<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

fn movq2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmMovsb for CodeAssembler

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

impl CodeAsmMovsd for CodeAssembler

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

impl CodeAsmMovsd2<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movsd_2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovsd2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movsd_2( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovsd2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movsd_2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movshdup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovshdup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movshdup( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movsldup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovsldup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movsldup( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovsq for CodeAssembler

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

impl CodeAsmMovss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movss( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovsw for CodeAssembler

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

impl CodeAsmMovsx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movsx( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister16, AsmRegister16> for CodeAssembler

fn movsx( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister16, AsmRegister8> for CodeAssembler

fn movsx( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movsx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister32, AsmRegister16> for CodeAssembler

fn movsx( &mut self, op0: AsmRegister32, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister32, AsmRegister8> for CodeAssembler

fn movsx( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movsx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister64, AsmRegister16> for CodeAssembler

fn movsx( &mut self, op0: AsmRegister64, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMovsx<AsmRegister64, AsmRegister8> for CodeAssembler

fn movsx( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmMovsxd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movsxd( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovsxd<AsmRegister16, AsmRegister16> for CodeAssembler

fn movsxd( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMovsxd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movsxd( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovsxd<AsmRegister32, AsmRegister32> for CodeAssembler

fn movsxd( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMovsxd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movsxd( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovsxd<AsmRegister64, AsmRegister32> for CodeAssembler

fn movsxd( &mut self, op0: AsmRegister64, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMovupd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movupd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovupd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movupd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovupd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movupd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovups<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn movups( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovups<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn movups( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovups<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn movups( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister16, AsmRegister16> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister16, AsmRegister8> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister32, AsmRegister16> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister32, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister32, AsmRegister8> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister64, AsmRegister16> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister64, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmMovzx<AsmRegister64, AsmRegister8> for CodeAssembler

fn movzx( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn mpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn mpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn mpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn mpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmMul<AsmMemoryOperand> for CodeAssembler

fn mul(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmMul<AsmRegister16> for CodeAssembler

fn mul(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmMul<AsmRegister32> for CodeAssembler

fn mul(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmMul<AsmRegister64> for CodeAssembler

fn mul(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmMul<AsmRegister8> for CodeAssembler

fn mul(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmMulpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn mulpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMulpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn mulpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMulps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn mulps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMulps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn mulps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMulsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn mulsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMulsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn mulsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMulss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn mulss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMulss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn mulss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmMulx<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn mulx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMulx<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

fn mulx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmMulx<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn mulx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmMulx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

fn mulx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmMwait for CodeAssembler

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

impl CodeAsmMwaitx for CodeAssembler

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

impl CodeAsmNeg<AsmMemoryOperand> for CodeAssembler

fn neg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmNeg<AsmRegister16> for CodeAssembler

fn neg(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmNeg<AsmRegister32> for CodeAssembler

fn neg(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmNeg<AsmRegister64> for CodeAssembler

fn neg(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmNeg<AsmRegister8> for CodeAssembler

fn neg(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmNop for CodeAssembler

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

impl CodeAsmNop1<AsmMemoryOperand> for CodeAssembler

fn nop_1(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmNop1<AsmRegister16> for CodeAssembler

fn nop_1(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmNop1<AsmRegister32> for CodeAssembler

fn nop_1(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmNop1<AsmRegister64> for CodeAssembler

fn nop_1(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmNot<AsmMemoryOperand> for CodeAssembler

fn not(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmNot<AsmRegister16> for CodeAssembler

fn not(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmNot<AsmRegister32> for CodeAssembler

fn not(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmNot<AsmRegister64> for CodeAssembler

fn not(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmNot<AsmRegister8> for CodeAssembler

fn not(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn or( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn or( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn or( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn or( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, i32> for CodeAssembler

fn or(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmOr<AsmMemoryOperand, u32> for CodeAssembler

fn or(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn or( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister16, AsmRegister16> for CodeAssembler

fn or( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister16, i32> for CodeAssembler

fn or(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister16, u32> for CodeAssembler

fn or(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn or( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister32, AsmRegister32> for CodeAssembler

fn or( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister32, i32> for CodeAssembler

fn or(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister32, u32> for CodeAssembler

fn or(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn or( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister64, AsmRegister64> for CodeAssembler

fn or( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister64, i32> for CodeAssembler

fn or(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn or( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister8, AsmRegister8> for CodeAssembler

fn or(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister8, i32> for CodeAssembler

fn or(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmOr<AsmRegister8, u32> for CodeAssembler

fn or(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmOrpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn orpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmOrpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn orpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmOrps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn orps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmOrps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn orps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmOut<AsmRegister16, AsmRegister16> for CodeAssembler

fn out( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmOut<AsmRegister16, AsmRegister32> for CodeAssembler

fn out( &mut self, op0: AsmRegister16, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmOut<AsmRegister16, AsmRegister8> for CodeAssembler

fn out( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmOut<i32, AsmRegister16> for CodeAssembler

fn out(&mut self, op0: i32, op1: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmOut<i32, AsmRegister32> for CodeAssembler

fn out(&mut self, op0: i32, op1: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmOut<i32, AsmRegister8> for CodeAssembler

fn out(&mut self, op0: i32, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmOut<u32, AsmRegister16> for CodeAssembler

fn out(&mut self, op0: u32, op1: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmOut<u32, AsmRegister32> for CodeAssembler

fn out(&mut self, op0: u32, op1: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmOut<u32, AsmRegister8> for CodeAssembler

fn out(&mut self, op0: u32, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmOutsb for CodeAssembler

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

impl CodeAsmOutsd for CodeAssembler

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

impl CodeAsmOutsw for CodeAssembler

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

impl CodeAsmPabsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pabsb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPabsb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pabsb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pabsb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPabsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pabsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPabsd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pabsd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPabsd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pabsd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pabsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPabsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pabsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPabsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pabsw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPabsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pabsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pabsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPabsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pabsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPackssdw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn packssdw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPackssdw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn packssdw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPackssdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn packssdw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPackssdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn packssdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPacksswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn packsswb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPacksswb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn packsswb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPacksswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn packsswb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPacksswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn packsswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPackusdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn packusdw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPackusdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn packusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPackuswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn packuswb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPackuswb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn packuswb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPackuswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn packuswb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPackuswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn packuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPaddb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paddb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPaddb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn paddb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paddd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn paddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPaddq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paddq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPaddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn paddq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPaddsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddsb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddsb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paddsb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPaddsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddsb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn paddsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPaddsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddsiw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddsiw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paddsiw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddsw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paddsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn paddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPaddusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddusb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddusb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paddusb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPaddusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddusb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddusb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn paddusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPaddusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddusw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddusw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paddusw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPaddusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddusw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddusw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn paddusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paddw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paddw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn paddw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaddw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn paddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

fn palignr( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

fn palignr( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterMm, AsmRegisterMm, i32> for CodeAssembler

fn palignr( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterMm, AsmRegisterMm, u32> for CodeAssembler

fn palignr( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn palignr( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn palignr( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn palignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPalignr<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn palignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPand<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pand( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPand<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pand( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPand<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pand( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPand<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pand( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPandn<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pandn( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPandn<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pandn( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPandn<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pandn( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPandn<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pandn( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPause for CodeAssembler

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

impl CodeAsmPaveb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn paveb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPaveb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn paveb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPavgb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pavgb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPavgb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pavgb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPavgb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pavgb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPavgb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pavgb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPavgusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pavgusb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPavgusb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pavgusb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPavgw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pavgw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPavgw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pavgw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPavgw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pavgw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPavgw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pavgw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPblendvb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pblendvb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPblendvb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pblendvb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPblendw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pblendw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPblendw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pblendw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPblendw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPblendw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPbndkb for CodeAssembler

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

impl CodeAsmPclmulhqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pclmulhqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pclmulhqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPclmulhqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pclmulhqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pclmulhqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPclmullqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pclmullqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pclmullqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPclmullqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pclmullqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pclmullqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pcmpeqb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pcmpeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pcmpeqd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pcmpeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pcmpeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pcmpeqw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpeqw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpeqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pcmpeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pcmpgtb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pcmpgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pcmpgtd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pcmpgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pcmpgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pcmpgtw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pcmpgtw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPcmpgtw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pcmpgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPcommit for CodeAssembler

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

impl CodeAsmPconfig for CodeAssembler

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

impl CodeAsmPdep<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn pdep( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPdep<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

fn pdep( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmPdep<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn pdep( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPdep<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

fn pdep( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmPdistib<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pdistib( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPext<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn pext( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPext<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

fn pext( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmPext<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn pext( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPext<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

fn pext( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmPextrb<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn pextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrb<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn pextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrb<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn pextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrb<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn pextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrb<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn pextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrb<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn pextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrd<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn pextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrd<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn pextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrd<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn pextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrd<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn pextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrq<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn pextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrq<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn pextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrq<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn pextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrq<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn pextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn pextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn pextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmRegister32, AsmRegisterMm, i32> for CodeAssembler

fn pextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterMm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmRegister32, AsmRegisterMm, u32> for CodeAssembler

fn pextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterMm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn pextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn pextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmRegister64, AsmRegisterMm, i32> for CodeAssembler

fn pextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterMm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmRegister64, AsmRegisterMm, u32> for CodeAssembler

fn pextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterMm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn pextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPextrw<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn pextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPf2id<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pf2id( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPf2id<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pf2id( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPf2iw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pf2iw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPf2iw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pf2iw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfacc( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfacc<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfacc( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfadd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfadd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfadd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfadd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfcmpeq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfcmpeq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfcmpeq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfcmpeq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfcmpge<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfcmpge( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfcmpge<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfcmpge( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfcmpgt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfcmpgt( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfcmpgt<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfcmpgt( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfmax<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfmax( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfmax<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfmax( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfmin<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfmin( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfmin<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfmin( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfmul<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfmul( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfmul<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfmul( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfnacc( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfnacc<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfnacc( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfpnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfpnacc( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfpnacc<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfpnacc( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfrcp<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrcp( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfrcp<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfrcp( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfrcpit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrcpit1( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfrcpit1<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfrcpit1( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfrcpit2<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrcpit2( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfrcpit2<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfrcpit2( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfrcpv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrcpv( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfrcpv<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfrcpv( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfrsqit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrsqit1( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfrsqit1<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfrsqit1( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfrsqrt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrsqrt( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfrsqrt<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfrsqrt( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfrsqrtv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfrsqrtv( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfrsqrtv<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfrsqrtv( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfsub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfsub( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfsub<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfsub( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPfsubr<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pfsubr( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPfsubr<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pfsubr( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPhaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phaddd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhaddd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn phaddd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPhaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phaddd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhaddd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn phaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPhaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phaddsw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhaddsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn phaddsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPhaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhaddsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn phaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPhaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phaddw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhaddw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn phaddw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPhaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phaddw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhaddw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn phaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPhminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phminposuw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhminposuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn phminposuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPhsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phsubd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhsubd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn phsubd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPhsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phsubd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhsubd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn phsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPhsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phsubsw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhsubsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn phsubsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPhsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhsubsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn phsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPhsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn phsubw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhsubw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn phsubw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPhsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn phsubw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPhsubw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn phsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPi2fd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pi2fd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPi2fd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pi2fd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPi2fw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pi2fw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPi2fw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pi2fw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPinsrb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrd<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

fn pinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrd<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

fn pinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrq<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

fn pinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrq<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

fn pinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister32, i32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister32, u32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister64, i32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister64, u32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPmachriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmachriw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaddubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmaddubsw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaddubsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmaddubsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmaddubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaddubsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaddubsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmaddubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmaddwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmaddwd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaddwd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmaddwd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaddwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmagw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmagw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmagw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmagw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmaxsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxsb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaxsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmaxsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaxsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmaxsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmaxsw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaxsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmaxsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmaxsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaxsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmaxsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmaxub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmaxub( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaxub<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmaxub( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmaxub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxub( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaxub<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmaxub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmaxud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxud( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaxud<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmaxud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmaxuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmaxuw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmaxuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmaxuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPminsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminsb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPminsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pminsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPminsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPminsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPminsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pminsw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPminsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pminsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPminsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPminsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pminsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPminub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pminub( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPminub<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pminub( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPminub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminub( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPminub<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pminub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPminud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminud( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPminud<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pminud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPminuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pminuw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPminuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pminuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovmskb<AsmRegister32, AsmRegisterMm> for CodeAssembler

fn pmovmskb( &mut self, op0: AsmRegister32, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmovmskb<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn pmovmskb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovmskb<AsmRegister64, AsmRegisterMm> for CodeAssembler

fn pmovmskb( &mut self, op0: AsmRegister64, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmovmskb<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn pmovmskb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovsxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovsxbd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovsxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovsxbq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovsxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovsxbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovsxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovsxdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovsxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovsxwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovsxwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovsxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovsxwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovzxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovzxbd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovzxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovzxbq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovzxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovzxbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovzxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovzxdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovzxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovzxwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmovzxwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmovzxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmovzxwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmuldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmuldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmuldq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmuldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmulhriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhriw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulhriw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmulhriw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmulhrsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhrsw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulhrsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmulhrsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmulhrsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmulhrsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulhrsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmulhrsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmulhrw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhrw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulhrw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmulhrw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmulhrw_cyrix<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhrw_cyrix( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulhrw_cyrix<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmulhrw_cyrix( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmulhuw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhuw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulhuw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmulhuw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmulhuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmulhuw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulhuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmulhuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmulhw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmulhw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulhw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmulhw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmulhw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmulhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulhw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmulhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmulld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmulld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmulld<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmulld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmullw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmullw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmullw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmullw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmullw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmullw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmullw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmullw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmuludq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmuludq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmuludq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pmuludq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPmuludq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pmuludq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmuludq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pmuludq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPmvgezb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmvgezb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmvlzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmvlzb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmvnzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmvnzb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPmvzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pmvzb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPop<AsmMemoryOperand> for CodeAssembler

fn pop(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPop<AsmRegister16> for CodeAssembler

fn pop(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmPop<AsmRegister32> for CodeAssembler

fn pop(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmPop<AsmRegister64> for CodeAssembler

fn pop(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmPop<AsmRegisterSegment> for CodeAssembler

fn pop(&mut self, op0: AsmRegisterSegment) -> Result<(), IcedError>

impl CodeAsmPopa for CodeAssembler

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

impl CodeAsmPopad for CodeAssembler

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

impl CodeAsmPopcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn popcnt( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPopcnt<AsmRegister16, AsmRegister16> for CodeAssembler

fn popcnt( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmPopcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn popcnt( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPopcnt<AsmRegister32, AsmRegister32> for CodeAssembler

fn popcnt( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmPopcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn popcnt( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPopcnt<AsmRegister64, AsmRegister64> for CodeAssembler

fn popcnt( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmPopf for CodeAssembler

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

impl CodeAsmPopfd for CodeAssembler

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

impl CodeAsmPopfq for CodeAssembler

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

impl CodeAsmPor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn por( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPor<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn por( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn por( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPor<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn por( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPrefetch<AsmMemoryOperand> for CodeAssembler

fn prefetch(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetchit0<AsmMemoryOperand> for CodeAssembler

fn prefetchit0(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetchit1<AsmMemoryOperand> for CodeAssembler

fn prefetchit1(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetchnta<AsmMemoryOperand> for CodeAssembler

fn prefetchnta(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetcht0<AsmMemoryOperand> for CodeAssembler

fn prefetcht0(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetcht1<AsmMemoryOperand> for CodeAssembler

fn prefetcht1(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetcht2<AsmMemoryOperand> for CodeAssembler

fn prefetcht2(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetchw<AsmMemoryOperand> for CodeAssembler

fn prefetchw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPrefetchwt1<AsmMemoryOperand> for CodeAssembler

fn prefetchwt1(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPsadbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psadbw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsadbw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psadbw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsadbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psadbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsadbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPshufb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pshufb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPshufb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pshufb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPshufb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pshufb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPshufb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pshufb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPshufd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPshufd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPshufd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPshufd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPshufhw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPshufhw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPshufhw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPshufhw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPshuflw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn pshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPshuflw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn pshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPshuflw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn pshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPshuflw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn pshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

fn pshufw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

fn pshufw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPshufw<AsmRegisterMm, AsmRegisterMm, i32> for CodeAssembler

fn pshufw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmPshufw<AsmRegisterMm, AsmRegisterMm, u32> for CodeAssembler

fn pshufw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmPsignb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psignb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsignb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psignb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsignb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psignb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsignb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psignb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsignd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psignd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsignd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psignd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsignd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psignd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsignd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsignw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psignw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsignw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psignw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsignw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psignw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsignw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psignw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pslld( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pslld( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterMm, i32> for CodeAssembler

fn pslld(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterMm, u32> for CodeAssembler

fn pslld(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pslld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterXmm, i32> for CodeAssembler

fn pslld(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPslld<AsmRegisterXmm, u32> for CodeAssembler

fn pslld(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPslldq<AsmRegisterXmm, i32> for CodeAssembler

fn pslldq(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPslldq<AsmRegisterXmm, u32> for CodeAssembler

fn pslldq(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psllq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psllq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterMm, i32> for CodeAssembler

fn psllq(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterMm, u32> for CodeAssembler

fn psllq(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psllq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterXmm, i32> for CodeAssembler

fn psllq(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsllq<AsmRegisterXmm, u32> for CodeAssembler

fn psllq(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psllw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psllw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterMm, i32> for CodeAssembler

fn psllw(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterMm, u32> for CodeAssembler

fn psllw(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psllw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterXmm, i32> for CodeAssembler

fn psllw(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsllw<AsmRegisterXmm, u32> for CodeAssembler

fn psllw(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsmash for CodeAssembler

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

impl CodeAsmPsrad<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psrad( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsrad<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psrad( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsrad<AsmRegisterMm, i32> for CodeAssembler

fn psrad(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsrad<AsmRegisterMm, u32> for CodeAssembler

fn psrad(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsrad<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psrad( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsrad<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsrad<AsmRegisterXmm, i32> for CodeAssembler

fn psrad(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsrad<AsmRegisterXmm, u32> for CodeAssembler

fn psrad(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psraw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psraw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterMm, i32> for CodeAssembler

fn psraw(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterMm, u32> for CodeAssembler

fn psraw(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psraw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterXmm, i32> for CodeAssembler

fn psraw(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsraw<AsmRegisterXmm, u32> for CodeAssembler

fn psraw(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psrld( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psrld( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterMm, i32> for CodeAssembler

fn psrld(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterMm, u32> for CodeAssembler

fn psrld(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psrld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterXmm, i32> for CodeAssembler

fn psrld(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsrld<AsmRegisterXmm, u32> for CodeAssembler

fn psrld(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsrldq<AsmRegisterXmm, i32> for CodeAssembler

fn psrldq(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsrldq<AsmRegisterXmm, u32> for CodeAssembler

fn psrldq(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psrlq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psrlq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterMm, i32> for CodeAssembler

fn psrlq(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterMm, u32> for CodeAssembler

fn psrlq(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psrlq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterXmm, i32> for CodeAssembler

fn psrlq(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsrlq<AsmRegisterXmm, u32> for CodeAssembler

fn psrlq(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psrlw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psrlw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterMm, i32> for CodeAssembler

fn psrlw(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterMm, u32> for CodeAssembler

fn psrlw(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psrlw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterXmm, i32> for CodeAssembler

fn psrlw(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

impl CodeAsmPsrlw<AsmRegisterXmm, u32> for CodeAssembler

fn psrlw(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

impl CodeAsmPsubb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psubb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsubb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psubb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psubd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsubq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psubq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psubq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsubsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubsb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubsb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psubsb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsubsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubsb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psubsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsubsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubsiw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubsiw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psubsiw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubsw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psubsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsubusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubusb( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubusb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psubusb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsubusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubusb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubusb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psubusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsubusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubusw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubusw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psubusw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsubusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubusw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubusw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psubusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn psubw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn psubw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn psubw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPsubw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn psubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPswapd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pswapd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPswapd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pswapd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPtest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn ptest( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPtest<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn ptest( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPtwrite<AsmMemoryOperand> for CodeAssembler

fn ptwrite(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPtwrite<AsmRegister32> for CodeAssembler

fn ptwrite(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmPtwrite<AsmRegister64> for CodeAssembler

fn ptwrite(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmPunpckhbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckhbw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckhbw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn punpckhbw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPunpckhbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckhbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn punpckhbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPunpckhdq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckhdq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckhdq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn punpckhdq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPunpckhdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckhdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn punpckhdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPunpckhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckhqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn punpckhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPunpckhwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckhwd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckhwd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn punpckhwd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPunpckhwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckhwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckhwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn punpckhwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPunpcklbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpcklbw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklbw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn punpcklbw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPunpcklbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpcklbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn punpcklbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPunpckldq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpckldq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckldq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn punpckldq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPunpckldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpckldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpckldq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn punpckldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPunpcklqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpcklqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn punpcklqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPunpcklwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn punpcklwd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklwd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn punpcklwd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPunpcklwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn punpcklwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPunpcklwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn punpcklwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmPush<AsmMemoryOperand> for CodeAssembler

fn push(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmPush<AsmRegister16> for CodeAssembler

fn push(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmPush<AsmRegister32> for CodeAssembler

fn push(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmPush<AsmRegister64> for CodeAssembler

fn push(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmPush<AsmRegisterSegment> for CodeAssembler

fn push(&mut self, op0: AsmRegisterSegment) -> Result<(), IcedError>

impl CodeAsmPush<i32> for CodeAssembler

fn push(&mut self, op0: i32) -> Result<(), IcedError>

impl CodeAsmPush<u32> for CodeAssembler

fn push(&mut self, op0: u32) -> Result<(), IcedError>

impl CodeAsmPusha for CodeAssembler

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

impl CodeAsmPushad for CodeAssembler

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

impl CodeAsmPushf for CodeAssembler

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

impl CodeAsmPushfd for CodeAssembler

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

impl CodeAsmPushfq for CodeAssembler

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

impl CodeAsmPvalidate for CodeAssembler

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

impl CodeAsmPxor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

fn pxor( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPxor<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

fn pxor( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

impl CodeAsmPxor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn pxor( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmPxor<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn pxor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmRcl<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn rcl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcl<AsmMemoryOperand, i32> for CodeAssembler

fn rcl(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmMemoryOperand, u32> for CodeAssembler

fn rcl(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister16, AsmRegister8> for CodeAssembler

fn rcl( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister16, i32> for CodeAssembler

fn rcl(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister16, u32> for CodeAssembler

fn rcl(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister32, AsmRegister8> for CodeAssembler

fn rcl( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister32, i32> for CodeAssembler

fn rcl(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister32, u32> for CodeAssembler

fn rcl(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister64, AsmRegister8> for CodeAssembler

fn rcl( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister64, i32> for CodeAssembler

fn rcl(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister64, u32> for CodeAssembler

fn rcl(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister8, AsmRegister8> for CodeAssembler

fn rcl(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister8, i32> for CodeAssembler

fn rcl(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcl<AsmRegister8, u32> for CodeAssembler

fn rcl(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rcpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRcpps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn rcpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmRcpss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rcpss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRcpss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn rcpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmRcr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn rcr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcr<AsmMemoryOperand, i32> for CodeAssembler

fn rcr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmMemoryOperand, u32> for CodeAssembler

fn rcr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister16, AsmRegister8> for CodeAssembler

fn rcr( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister16, i32> for CodeAssembler

fn rcr(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister16, u32> for CodeAssembler

fn rcr(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister32, AsmRegister8> for CodeAssembler

fn rcr( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister32, i32> for CodeAssembler

fn rcr(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister32, u32> for CodeAssembler

fn rcr(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister64, AsmRegister8> for CodeAssembler

fn rcr( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister64, i32> for CodeAssembler

fn rcr(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister64, u32> for CodeAssembler

fn rcr(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister8, AsmRegister8> for CodeAssembler

fn rcr(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister8, i32> for CodeAssembler

fn rcr(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmRcr<AsmRegister8, u32> for CodeAssembler

fn rcr(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmRdfsbase<AsmRegister32> for CodeAssembler

fn rdfsbase(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmRdfsbase<AsmRegister64> for CodeAssembler

fn rdfsbase(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdgsbase<AsmRegister32> for CodeAssembler

fn rdgsbase(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmRdgsbase<AsmRegister64> for CodeAssembler

fn rdgsbase(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdm for CodeAssembler

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

impl CodeAsmRdmsr for CodeAssembler

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

impl CodeAsmRdmsrlist for CodeAssembler

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

impl CodeAsmRdpid<AsmRegister32> for CodeAssembler

fn rdpid(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmRdpid<AsmRegister64> for CodeAssembler

fn rdpid(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdpkru for CodeAssembler

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

impl CodeAsmRdpmc for CodeAssembler

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

impl CodeAsmRdpru for CodeAssembler

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

impl CodeAsmRdrand<AsmRegister16> for CodeAssembler

fn rdrand(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmRdrand<AsmRegister32> for CodeAssembler

fn rdrand(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmRdrand<AsmRegister64> for CodeAssembler

fn rdrand(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdseed<AsmRegister16> for CodeAssembler

fn rdseed(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmRdseed<AsmRegister32> for CodeAssembler

fn rdseed(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmRdseed<AsmRegister64> for CodeAssembler

fn rdseed(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdshr<AsmMemoryOperand> for CodeAssembler

fn rdshr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmRdshr<AsmRegister32> for CodeAssembler

fn rdshr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmRdsspd<AsmRegister32> for CodeAssembler

fn rdsspd(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmRdsspq<AsmRegister64> for CodeAssembler

fn rdsspq(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmRdtsc for CodeAssembler

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

impl CodeAsmRdtscp for CodeAssembler

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

impl CodeAsmRdudbg for CodeAssembler

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

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f0d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f0d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f0d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmRegister16, AsmRegister16> for CodeAssembler

fn reservednop_0f0d( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmRegister32, AsmRegister32> for CodeAssembler

fn reservednop_0f0d( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f0d<AsmRegister64, AsmRegister64> for CodeAssembler

fn reservednop_0f0d( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f18( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f18( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f18( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmRegister16, AsmRegister16> for CodeAssembler

fn reservednop_0f18( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmRegister32, AsmRegister32> for CodeAssembler

fn reservednop_0f18( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f18<AsmRegister64, AsmRegister64> for CodeAssembler

fn reservednop_0f18( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f19( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f19( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f19( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmRegister16, AsmRegister16> for CodeAssembler

fn reservednop_0f19( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmRegister32, AsmRegister32> for CodeAssembler

fn reservednop_0f19( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f19<AsmRegister64, AsmRegister64> for CodeAssembler

fn reservednop_0f19( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1a( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1a( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1a( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmRegister16, AsmRegister16> for CodeAssembler

fn reservednop_0f1a( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmRegister32, AsmRegister32> for CodeAssembler

fn reservednop_0f1a( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1a<AsmRegister64, AsmRegister64> for CodeAssembler

fn reservednop_0f1a( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1b( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1b( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1b( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmRegister16, AsmRegister16> for CodeAssembler

fn reservednop_0f1b( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmRegister32, AsmRegister32> for CodeAssembler

fn reservednop_0f1b( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1b<AsmRegister64, AsmRegister64> for CodeAssembler

fn reservednop_0f1b( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1c( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1c( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1c( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmRegister16, AsmRegister16> for CodeAssembler

fn reservednop_0f1c( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmRegister32, AsmRegister32> for CodeAssembler

fn reservednop_0f1c( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1c<AsmRegister64, AsmRegister64> for CodeAssembler

fn reservednop_0f1c( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1d( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmRegister16, AsmRegister16> for CodeAssembler

fn reservednop_0f1d( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmRegister32, AsmRegister32> for CodeAssembler

fn reservednop_0f1d( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1d<AsmRegister64, AsmRegister64> for CodeAssembler

fn reservednop_0f1d( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1e( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1e( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1e( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmRegister16, AsmRegister16> for CodeAssembler

fn reservednop_0f1e( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmRegister32, AsmRegister32> for CodeAssembler

fn reservednop_0f1e( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1e<AsmRegister64, AsmRegister64> for CodeAssembler

fn reservednop_0f1e( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn reservednop_0f1f( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn reservednop_0f1f( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn reservednop_0f1f( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmRegister16, AsmRegister16> for CodeAssembler

fn reservednop_0f1f( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmRegister32, AsmRegister32> for CodeAssembler

fn reservednop_0f1f( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmReservednop_0f1f<AsmRegister64, AsmRegister64> for CodeAssembler

fn reservednop_0f1f( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmRet for CodeAssembler

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

impl CodeAsmRet1<i32> for CodeAssembler

fn ret_1(&mut self, op0: i32) -> Result<(), IcedError>

impl CodeAsmRet1<u32> for CodeAssembler

fn ret_1(&mut self, op0: u32) -> Result<(), IcedError>

impl CodeAsmRetf for CodeAssembler

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

impl CodeAsmRetf1<i32> for CodeAssembler

fn retf_1(&mut self, op0: i32) -> Result<(), IcedError>

impl CodeAsmRetf1<u32> for CodeAssembler

fn retf_1(&mut self, op0: u32) -> Result<(), IcedError>

impl CodeAsmRmpadjust for CodeAssembler

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

impl CodeAsmRmpquery for CodeAssembler

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

impl CodeAsmRmpupdate for CodeAssembler

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

impl CodeAsmRol<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn rol( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRol<AsmMemoryOperand, i32> for CodeAssembler

fn rol(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRol<AsmMemoryOperand, u32> for CodeAssembler

fn rol(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister16, AsmRegister8> for CodeAssembler

fn rol( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister16, i32> for CodeAssembler

fn rol(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister16, u32> for CodeAssembler

fn rol(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister32, AsmRegister8> for CodeAssembler

fn rol( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister32, i32> for CodeAssembler

fn rol(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister32, u32> for CodeAssembler

fn rol(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister64, AsmRegister8> for CodeAssembler

fn rol( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister64, i32> for CodeAssembler

fn rol(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister64, u32> for CodeAssembler

fn rol(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister8, AsmRegister8> for CodeAssembler

fn rol(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister8, i32> for CodeAssembler

fn rol(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmRol<AsmRegister8, u32> for CodeAssembler

fn rol(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmRor<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn ror( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRor<AsmMemoryOperand, i32> for CodeAssembler

fn ror(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmRor<AsmMemoryOperand, u32> for CodeAssembler

fn ror(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister16, AsmRegister8> for CodeAssembler

fn ror( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister16, i32> for CodeAssembler

fn ror(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister16, u32> for CodeAssembler

fn ror(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister32, AsmRegister8> for CodeAssembler

fn ror( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister32, i32> for CodeAssembler

fn ror(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister32, u32> for CodeAssembler

fn ror(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister64, AsmRegister8> for CodeAssembler

fn ror( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister64, i32> for CodeAssembler

fn ror(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister64, u32> for CodeAssembler

fn ror(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister8, AsmRegister8> for CodeAssembler

fn ror(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister8, i32> for CodeAssembler

fn ror(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmRor<AsmRegister8, u32> for CodeAssembler

fn ror(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister32, AsmRegister32, i32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister32, AsmRegister32, u32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister64, AsmRegister64, i32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRorx<AsmRegister64, AsmRegister64, u32> for CodeAssembler

fn rorx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRoundpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn roundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRoundpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn roundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRoundpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn roundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRoundpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn roundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRoundps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn roundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRoundps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn roundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRoundps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn roundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRoundps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn roundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRoundsd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn roundsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRoundsd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn roundsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRoundsd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn roundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRoundsd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn roundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRoundss<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn roundss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRoundss<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn roundss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRoundss<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn roundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmRoundss<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn roundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmRsdc<AsmRegisterSegment, AsmMemoryOperand> for CodeAssembler

fn rsdc( &mut self, op0: AsmRegisterSegment, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRsldt<AsmMemoryOperand> for CodeAssembler

fn rsldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmRsm for CodeAssembler

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

impl CodeAsmRsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRsqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn rsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmRsqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn rsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmRsqrtss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn rsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmRstorssp<AsmMemoryOperand> for CodeAssembler

fn rstorssp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmRsts<AsmMemoryOperand> for CodeAssembler

fn rsts(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSahf for CodeAssembler

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

impl CodeAsmSal<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sal( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSal<AsmMemoryOperand, i32> for CodeAssembler

fn sal(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSal<AsmMemoryOperand, u32> for CodeAssembler

fn sal(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister16, AsmRegister8> for CodeAssembler

fn sal( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister16, i32> for CodeAssembler

fn sal(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister16, u32> for CodeAssembler

fn sal(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister32, AsmRegister8> for CodeAssembler

fn sal( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister32, i32> for CodeAssembler

fn sal(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister32, u32> for CodeAssembler

fn sal(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister64, AsmRegister8> for CodeAssembler

fn sal( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister64, i32> for CodeAssembler

fn sal(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister64, u32> for CodeAssembler

fn sal(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister8, AsmRegister8> for CodeAssembler

fn sal(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister8, i32> for CodeAssembler

fn sal(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmSal<AsmRegister8, u32> for CodeAssembler

fn sal(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmSalc for CodeAssembler

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

impl CodeAsmSar<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sar( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSar<AsmMemoryOperand, i32> for CodeAssembler

fn sar(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSar<AsmMemoryOperand, u32> for CodeAssembler

fn sar(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister16, AsmRegister8> for CodeAssembler

fn sar( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister16, i32> for CodeAssembler

fn sar(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister16, u32> for CodeAssembler

fn sar(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister32, AsmRegister8> for CodeAssembler

fn sar( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister32, i32> for CodeAssembler

fn sar(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister32, u32> for CodeAssembler

fn sar(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister64, AsmRegister8> for CodeAssembler

fn sar( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister64, i32> for CodeAssembler

fn sar(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister64, u32> for CodeAssembler

fn sar(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister8, AsmRegister8> for CodeAssembler

fn sar(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister8, i32> for CodeAssembler

fn sar(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmSar<AsmRegister8, u32> for CodeAssembler

fn sar(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmSarx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn sarx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmSarx<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

fn sarx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmSarx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn sarx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmSarx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

fn sarx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmSaveprevssp for CodeAssembler

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

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, i32> for CodeAssembler

fn sbb(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmMemoryOperand, u32> for CodeAssembler

fn sbb(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister16, AsmRegister16> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister16, i32> for CodeAssembler

fn sbb(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister16, u32> for CodeAssembler

fn sbb(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister32, AsmRegister32> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister32, i32> for CodeAssembler

fn sbb(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister32, u32> for CodeAssembler

fn sbb(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister64, AsmRegister64> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister64, i32> for CodeAssembler

fn sbb(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn sbb( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister8, AsmRegister8> for CodeAssembler

fn sbb(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister8, i32> for CodeAssembler

fn sbb(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmSbb<AsmRegister8, u32> for CodeAssembler

fn sbb(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmScasb for CodeAssembler

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

impl CodeAsmScasd for CodeAssembler

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

impl CodeAsmScasq for CodeAssembler

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

impl CodeAsmScasw for CodeAssembler

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

impl CodeAsmSeamcall for CodeAssembler

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

impl CodeAsmSeamops for CodeAssembler

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

impl CodeAsmSeamret for CodeAssembler

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

impl CodeAsmSenduipi<AsmRegister64> for CodeAssembler

fn senduipi(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmSerialize for CodeAssembler

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

impl CodeAsmSeta<AsmMemoryOperand> for CodeAssembler

fn seta(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSeta<AsmRegister8> for CodeAssembler

fn seta(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetae<AsmMemoryOperand> for CodeAssembler

fn setae(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetae<AsmRegister8> for CodeAssembler

fn setae(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetb<AsmMemoryOperand> for CodeAssembler

fn setb(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetb<AsmRegister8> for CodeAssembler

fn setb(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetbe<AsmMemoryOperand> for CodeAssembler

fn setbe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetbe<AsmRegister8> for CodeAssembler

fn setbe(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetc<AsmMemoryOperand> for CodeAssembler

fn setc(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetc<AsmRegister8> for CodeAssembler

fn setc(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSete<AsmMemoryOperand> for CodeAssembler

fn sete(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSete<AsmRegister8> for CodeAssembler

fn sete(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetg<AsmMemoryOperand> for CodeAssembler

fn setg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetg<AsmRegister8> for CodeAssembler

fn setg(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetge<AsmMemoryOperand> for CodeAssembler

fn setge(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetge<AsmRegister8> for CodeAssembler

fn setge(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetl<AsmMemoryOperand> for CodeAssembler

fn setl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetl<AsmRegister8> for CodeAssembler

fn setl(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetle<AsmMemoryOperand> for CodeAssembler

fn setle(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetle<AsmRegister8> for CodeAssembler

fn setle(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetna<AsmMemoryOperand> for CodeAssembler

fn setna(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetna<AsmRegister8> for CodeAssembler

fn setna(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetnae<AsmMemoryOperand> for CodeAssembler

fn setnae(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnae<AsmRegister8> for CodeAssembler

fn setnae(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetnb<AsmMemoryOperand> for CodeAssembler

fn setnb(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnb<AsmRegister8> for CodeAssembler

fn setnb(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetnbe<AsmMemoryOperand> for CodeAssembler

fn setnbe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnbe<AsmRegister8> for CodeAssembler

fn setnbe(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetnc<AsmMemoryOperand> for CodeAssembler

fn setnc(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnc<AsmRegister8> for CodeAssembler

fn setnc(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetne<AsmMemoryOperand> for CodeAssembler

fn setne(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetne<AsmRegister8> for CodeAssembler

fn setne(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetng<AsmMemoryOperand> for CodeAssembler

fn setng(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetng<AsmRegister8> for CodeAssembler

fn setng(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetnge<AsmMemoryOperand> for CodeAssembler

fn setnge(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnge<AsmRegister8> for CodeAssembler

fn setnge(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetnl<AsmMemoryOperand> for CodeAssembler

fn setnl(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnl<AsmRegister8> for CodeAssembler

fn setnl(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetnle<AsmMemoryOperand> for CodeAssembler

fn setnle(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnle<AsmRegister8> for CodeAssembler

fn setnle(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetno<AsmMemoryOperand> for CodeAssembler

fn setno(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetno<AsmRegister8> for CodeAssembler

fn setno(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetnp<AsmMemoryOperand> for CodeAssembler

fn setnp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnp<AsmRegister8> for CodeAssembler

fn setnp(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetns<AsmMemoryOperand> for CodeAssembler

fn setns(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetns<AsmRegister8> for CodeAssembler

fn setns(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetnz<AsmMemoryOperand> for CodeAssembler

fn setnz(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetnz<AsmRegister8> for CodeAssembler

fn setnz(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSeto<AsmMemoryOperand> for CodeAssembler

fn seto(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSeto<AsmRegister8> for CodeAssembler

fn seto(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetp<AsmMemoryOperand> for CodeAssembler

fn setp(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetp<AsmRegister8> for CodeAssembler

fn setp(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetpe<AsmMemoryOperand> for CodeAssembler

fn setpe(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetpe<AsmRegister8> for CodeAssembler

fn setpe(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetpo<AsmMemoryOperand> for CodeAssembler

fn setpo(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetpo<AsmRegister8> for CodeAssembler

fn setpo(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSets<AsmMemoryOperand> for CodeAssembler

fn sets(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSets<AsmRegister8> for CodeAssembler

fn sets(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSetssbsy for CodeAssembler

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

impl CodeAsmSetz<AsmMemoryOperand> for CodeAssembler

fn setz(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSetz<AsmRegister8> for CodeAssembler

fn setz(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSfence for CodeAssembler

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

impl CodeAsmSgdt<AsmMemoryOperand> for CodeAssembler

fn sgdt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSha1msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha1msg1( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha1msg1<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sha1msg1( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSha1msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha1msg2( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha1msg2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sha1msg2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSha1nexte<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha1nexte( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha1nexte<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sha1nexte( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn sha1rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn sha1rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn sha1rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn sha1rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmSha256msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha256msg1( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha256msg1<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sha256msg1( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSha256msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha256msg2( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha256msg2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sha256msg2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSha256rnds2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sha256rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSha256rnds2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sha256rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmShl<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn shl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShl<AsmMemoryOperand, i32> for CodeAssembler

fn shl(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmShl<AsmMemoryOperand, u32> for CodeAssembler

fn shl(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister16, AsmRegister8> for CodeAssembler

fn shl( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister16, i32> for CodeAssembler

fn shl(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister16, u32> for CodeAssembler

fn shl(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister32, AsmRegister8> for CodeAssembler

fn shl( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister32, i32> for CodeAssembler

fn shl(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister32, u32> for CodeAssembler

fn shl(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister64, AsmRegister8> for CodeAssembler

fn shl( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister64, i32> for CodeAssembler

fn shl(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister64, u32> for CodeAssembler

fn shl(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister8, AsmRegister8> for CodeAssembler

fn shl(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister8, i32> for CodeAssembler

fn shl(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmShl<AsmRegister8, u32> for CodeAssembler

fn shl(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, AsmRegister8> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, i32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, u32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, AsmRegister8> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, i32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, u32> for CodeAssembler

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmRegister16, AsmRegister16, AsmRegister8> for CodeAssembler

fn shld( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmRegister16, AsmRegister16, i32> for CodeAssembler

fn shld( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmRegister16, AsmRegister16, u32> for CodeAssembler

fn shld( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmRegister32, AsmRegister32, AsmRegister8> for CodeAssembler

fn shld( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmRegister32, AsmRegister32, i32> for CodeAssembler

fn shld( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmRegister32, AsmRegister32, u32> for CodeAssembler

fn shld( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmRegister64, AsmRegister64, AsmRegister8> for CodeAssembler

fn shld( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmRegister64, AsmRegister64, i32> for CodeAssembler

fn shld( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShld<AsmRegister64, AsmRegister64, u32> for CodeAssembler

fn shld( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShlx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn shlx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmShlx<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

fn shlx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmShlx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn shlx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmShlx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

fn shlx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmShr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn shr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShr<AsmMemoryOperand, i32> for CodeAssembler

fn shr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmShr<AsmMemoryOperand, u32> for CodeAssembler

fn shr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister16, AsmRegister8> for CodeAssembler

fn shr( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister16, i32> for CodeAssembler

fn shr(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister16, u32> for CodeAssembler

fn shr(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister32, AsmRegister8> for CodeAssembler

fn shr( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister32, i32> for CodeAssembler

fn shr(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister32, u32> for CodeAssembler

fn shr(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister64, AsmRegister8> for CodeAssembler

fn shr( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister64, i32> for CodeAssembler

fn shr(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister64, u32> for CodeAssembler

fn shr(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister8, AsmRegister8> for CodeAssembler

fn shr(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister8, i32> for CodeAssembler

fn shr(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmShr<AsmRegister8, u32> for CodeAssembler

fn shr(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, AsmRegister8> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, i32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, u32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, AsmRegister8> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, i32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, u32> for CodeAssembler

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmRegister16, AsmRegister16, AsmRegister8> for CodeAssembler

fn shrd( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmRegister16, AsmRegister16, i32> for CodeAssembler

fn shrd( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmRegister16, AsmRegister16, u32> for CodeAssembler

fn shrd( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmRegister32, AsmRegister32, AsmRegister8> for CodeAssembler

fn shrd( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmRegister32, AsmRegister32, i32> for CodeAssembler

fn shrd( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmRegister32, AsmRegister32, u32> for CodeAssembler

fn shrd( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmRegister64, AsmRegister64, AsmRegister8> for CodeAssembler

fn shrd( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmRegister64, AsmRegister64, i32> for CodeAssembler

fn shrd( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShrd<AsmRegister64, AsmRegister64, u32> for CodeAssembler

fn shrd( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShrx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn shrx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmShrx<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

fn shrx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmShrx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn shrx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmShrx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

fn shrx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShufpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShufpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShufps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn shufps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShufps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn shufps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmShufps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn shufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmShufps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn shufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmSidt<AsmMemoryOperand> for CodeAssembler

fn sidt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSkinit for CodeAssembler

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

impl CodeAsmSldt<AsmMemoryOperand> for CodeAssembler

fn sldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSldt<AsmRegister16> for CodeAssembler

fn sldt(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmSldt<AsmRegister32> for CodeAssembler

fn sldt(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmSldt<AsmRegister64> for CodeAssembler

fn sldt(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmSlwpcb<AsmRegister32> for CodeAssembler

fn slwpcb(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmSlwpcb<AsmRegister64> for CodeAssembler

fn slwpcb(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmSmint for CodeAssembler

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

impl CodeAsmSmint_0f7e for CodeAssembler

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

impl CodeAsmSmsw<AsmMemoryOperand> for CodeAssembler

fn smsw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSmsw<AsmRegister16> for CodeAssembler

fn smsw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmSmsw<AsmRegister32> for CodeAssembler

fn smsw(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmSmsw<AsmRegister64> for CodeAssembler

fn smsw(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmSqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSqrtpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sqrtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSqrtsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSqrtsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sqrtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn sqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSqrtss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn sqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmStac for CodeAssembler

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

impl CodeAsmStc for CodeAssembler

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

impl CodeAsmStd for CodeAssembler

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

impl CodeAsmStgi for CodeAssembler

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

impl CodeAsmSti for CodeAssembler

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

impl CodeAsmStmxcsr<AsmMemoryOperand> for CodeAssembler

fn stmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmStosb for CodeAssembler

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

impl CodeAsmStosd for CodeAssembler

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

impl CodeAsmStosq for CodeAssembler

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

impl CodeAsmStosw for CodeAssembler

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

impl CodeAsmStr<AsmMemoryOperand> for CodeAssembler

fn str(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmStr<AsmRegister16> for CodeAssembler

fn str(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmStr<AsmRegister32> for CodeAssembler

fn str(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmStr<AsmRegister64> for CodeAssembler

fn str(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmSttilecfg<AsmMemoryOperand> for CodeAssembler

fn sttilecfg(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmStui for CodeAssembler

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

impl CodeAsmSub<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, i32> for CodeAssembler

fn sub(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmSub<AsmMemoryOperand, u32> for CodeAssembler

fn sub(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn sub( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister16, AsmRegister16> for CodeAssembler

fn sub( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister16, i32> for CodeAssembler

fn sub(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister16, u32> for CodeAssembler

fn sub(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn sub( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister32, AsmRegister32> for CodeAssembler

fn sub( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister32, i32> for CodeAssembler

fn sub(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister32, u32> for CodeAssembler

fn sub(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn sub( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister64, AsmRegister64> for CodeAssembler

fn sub( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister64, i32> for CodeAssembler

fn sub(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn sub( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister8, AsmRegister8> for CodeAssembler

fn sub(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister8, i32> for CodeAssembler

fn sub(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmSub<AsmRegister8, u32> for CodeAssembler

fn sub(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmSubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSubpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn subpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSubps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn subps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSubsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSubsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn subsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSubss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn subss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmSubss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn subss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmSvdc<AsmMemoryOperand, AsmRegisterSegment> for CodeAssembler

fn svdc( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterSegment, ) -> Result<(), IcedError>

impl CodeAsmSvldt<AsmMemoryOperand> for CodeAssembler

fn svldt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSvts<AsmMemoryOperand> for CodeAssembler

fn svts(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmSwapgs for CodeAssembler

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

impl CodeAsmSyscall for CodeAssembler

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

impl CodeAsmSysenter for CodeAssembler

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

impl CodeAsmSysexit for CodeAssembler

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

impl CodeAsmSysexitq for CodeAssembler

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

impl CodeAsmSysret for CodeAssembler

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

impl CodeAsmSysretq for CodeAssembler

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

impl CodeAsmT1mskc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn t1mskc( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmT1mskc<AsmRegister32, AsmRegister32> for CodeAssembler

fn t1mskc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmT1mskc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn t1mskc( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmT1mskc<AsmRegister64, AsmRegister64> for CodeAssembler

fn t1mskc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmTcmmimfp16ps<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

fn tcmmimfp16ps( &mut self, op0: AsmRegisterTmm, op1: AsmRegisterTmm, op2: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTcmmrlfp16ps<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

fn tcmmrlfp16ps( &mut self, op0: AsmRegisterTmm, op1: AsmRegisterTmm, op2: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTdcall for CodeAssembler

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

impl CodeAsmTdpbf16ps<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

fn tdpbf16ps( &mut self, op0: AsmRegisterTmm, op1: AsmRegisterTmm, op2: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTdpbssd<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

fn tdpbssd( &mut self, op0: AsmRegisterTmm, op1: AsmRegisterTmm, op2: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTdpbsud<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

fn tdpbsud( &mut self, op0: AsmRegisterTmm, op1: AsmRegisterTmm, op2: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTdpbusd<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

fn tdpbusd( &mut self, op0: AsmRegisterTmm, op1: AsmRegisterTmm, op2: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTdpbuud<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

fn tdpbuud( &mut self, op0: AsmRegisterTmm, op1: AsmRegisterTmm, op2: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTdpfp16ps<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

fn tdpfp16ps( &mut self, op0: AsmRegisterTmm, op1: AsmRegisterTmm, op2: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, i32> for CodeAssembler

fn test(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmTest<AsmMemoryOperand, u32> for CodeAssembler

fn test(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister16, AsmRegister16> for CodeAssembler

fn test( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister16, i32> for CodeAssembler

fn test(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister16, u32> for CodeAssembler

fn test(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister32, AsmRegister32> for CodeAssembler

fn test( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister32, i32> for CodeAssembler

fn test(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister32, u32> for CodeAssembler

fn test(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister64, AsmRegister64> for CodeAssembler

fn test( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister64, i32> for CodeAssembler

fn test(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister8, AsmRegister8> for CodeAssembler

fn test( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister8, i32> for CodeAssembler

fn test(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmTest<AsmRegister8, u32> for CodeAssembler

fn test(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmTestui for CodeAssembler

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

impl CodeAsmTileloadd<AsmRegisterTmm, AsmMemoryOperand> for CodeAssembler

fn tileloadd( &mut self, op0: AsmRegisterTmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTileloaddt1<AsmRegisterTmm, AsmMemoryOperand> for CodeAssembler

fn tileloaddt1( &mut self, op0: AsmRegisterTmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTilerelease for CodeAssembler

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

impl CodeAsmTilestored<AsmMemoryOperand, AsmRegisterTmm> for CodeAssembler

fn tilestored( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterTmm, ) -> Result<(), IcedError>

impl CodeAsmTilezero<AsmRegisterTmm> for CodeAssembler

fn tilezero(&mut self, op0: AsmRegisterTmm) -> Result<(), IcedError>

impl CodeAsmTlbsync for CodeAssembler

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

impl CodeAsmTpause<AsmRegister32> for CodeAssembler

fn tpause(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmTpause<AsmRegister64> for CodeAssembler

fn tpause(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn tzcnt( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister16, AsmRegister16> for CodeAssembler

fn tzcnt( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn tzcnt( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister32, AsmRegister32> for CodeAssembler

fn tzcnt( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn tzcnt( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTzcnt<AsmRegister64, AsmRegister64> for CodeAssembler

fn tzcnt( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmTzmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn tzmsk( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTzmsk<AsmRegister32, AsmRegister32> for CodeAssembler

fn tzmsk( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmTzmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn tzmsk( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmTzmsk<AsmRegister64, AsmRegister64> for CodeAssembler

fn tzmsk( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmUcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn ucomisd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUcomisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn ucomisd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmUcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn ucomiss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUcomiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn ucomiss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmUd0 for CodeAssembler

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

impl CodeAsmUd02<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn ud0_2( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister16, AsmRegister16> for CodeAssembler

fn ud0_2( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn ud0_2( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister32, AsmRegister32> for CodeAssembler

fn ud0_2( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn ud0_2( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd02<AsmRegister64, AsmRegister64> for CodeAssembler

fn ud0_2( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn ud1( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister16, AsmRegister16> for CodeAssembler

fn ud1( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn ud1( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister32, AsmRegister32> for CodeAssembler

fn ud1( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn ud1( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUd1<AsmRegister64, AsmRegister64> for CodeAssembler

fn ud1( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmUd2 for CodeAssembler

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

impl CodeAsmUiret for CodeAssembler

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

impl CodeAsmUmonitor<AsmRegister16> for CodeAssembler

fn umonitor(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmUmonitor<AsmRegister32> for CodeAssembler

fn umonitor(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmUmonitor<AsmRegister64> for CodeAssembler

fn umonitor(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn umov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn umov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn umov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn umov( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister16, AsmRegister16> for CodeAssembler

fn umov( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn umov( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister32, AsmRegister32> for CodeAssembler

fn umov( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn umov( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUmov<AsmRegister8, AsmRegister8> for CodeAssembler

fn umov( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmUmwait<AsmRegister32> for CodeAssembler

fn umwait(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmUmwait<AsmRegister64> for CodeAssembler

fn umwait(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmUnpckhpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpckhpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUnpckhpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn unpckhpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmUnpckhps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpckhps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUnpckhps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn unpckhps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmUnpcklpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpcklpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUnpcklpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn unpcklpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmUnpcklps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn unpcklps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmUnpcklps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn unpcklps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmV4fmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn v4fmaddps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmV4fmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn v4fmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmV4fnmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn v4fnmaddps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmV4fnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn v4fnmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaddpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vaddpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaddph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vaddph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaddph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vaddph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaddps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vaddps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaddsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaddsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaddsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vaddsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaddsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaddsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vaddsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesdec( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaesdec( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesdec( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vaesdec( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesdec( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdec<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vaesdec( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesdeclast( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaesdeclast( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesdeclast( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vaesdeclast( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesdeclast( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesdeclast<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vaesdeclast( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesenc( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaesenc( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesenc( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vaesenc( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesenc( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenc<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vaesenc( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesenclast( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaesenclast( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vaesenclast( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vaesenclast( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vaesenclast( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesenclast<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vaesenclast( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVaesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vaesimc( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVaesimc<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vaesimc( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vaeskeygenassist( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vaeskeygenassist( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vaeskeygenassist( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vaeskeygenassist( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandnpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vandnpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandnpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vandnpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandnpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vandnpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandnps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vandnps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandnps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vandnps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandnps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandnps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vandnps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vandpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vandpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vandpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vandps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vandps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vandps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vandps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vandps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVandps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vandps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVbcstnebf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbcstnebf162ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbcstnebf162ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbcstnebf162ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbcstnesh2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbcstnesh2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbcstnesh2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbcstnesh2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vblendmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vblendmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vblendmpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vblendmpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vblendmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vblendmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vblendmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vblendmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vblendmps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vblendmps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vblendmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVblendmps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vblendmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vblendpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vblendps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVblendvpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vblendvpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vblendvpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vblendvpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vblendvpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vblendvps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vblendvps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vblendvps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVblendvps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vblendvps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf128<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf128( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x2( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x2<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastf32x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x2( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x2<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastf32x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x4<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf64x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastf64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti128<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti128( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x2<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcasti32x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x4<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti64x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcasti64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcasti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastsd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastsd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastsd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastsd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVbroadcastss<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vbroadcastss( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpeqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpeqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalse_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpfalsess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpge_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpgtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpgtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmple_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmplt_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpltss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_oqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ossd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ossd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ossh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_osss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_osss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneq_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpneqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpneqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnge_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpngtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpngtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnle_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnlt_uqss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpnltss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpnltss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_ssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_ssh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpordss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomisd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcomisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcomisd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomish( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcomish<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcomish( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcomiss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcomiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcomiss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtne2ps2bf16( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtneebf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneebf162ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneebf162ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneebf162ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneeph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneeph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneeph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneeph2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneobf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneobf162ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneobf162ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneobf162ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneoph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneoph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneoph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneoph2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16x<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16x( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtneps2bf16y<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtneps2bf16y( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dqx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2dqy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2phz( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ps<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2psx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2psy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udqx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2udqy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2ps<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2udq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phxx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phxx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phxy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2phxy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vcvtqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2phz( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ps<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2psx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtqq2psy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsd2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsd2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtsd2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtsh2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsh2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtsh2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtsi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtsi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtsi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtsi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtss2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtss2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtss2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtss2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtss2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtss2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtss2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtss2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvtss2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvtss2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvtss2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtss2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvtss2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dqx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2dqy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udqx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2udqy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2udq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttsd2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttsd2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttsd2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsd2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsd2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttsd2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttsh2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttsh2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttsh2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttsh2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttsh2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttsh2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttss2si( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttss2si( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttss2si( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttss2si( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vcvttss2usi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vcvttss2usi( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vcvttss2usi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvttss2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vcvttss2usi( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtuqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtuqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vcvtuqq2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2phx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2phy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2phz( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ps<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2psx( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuqq2psy( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtusi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtusi2sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtusi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtusi2sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtusi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vcvtusi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vcvtusi2ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vdivpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vdivph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vdivps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVdivsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVdivsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVdivss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdivss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdivss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdivss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVdpbf16ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vdpbf16ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVerr<AsmMemoryOperand> for CodeAssembler

fn verr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVerr<AsmRegister16> for CodeAssembler

fn verr(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmVerr<AsmRegister32> for CodeAssembler

fn verr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmVerr<AsmRegister64> for CodeAssembler

fn verr(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmVerw<AsmMemoryOperand> for CodeAssembler

fn verw(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVerw<AsmRegister16> for CodeAssembler

fn verw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

impl CodeAsmVerw<AsmRegister32> for CodeAssembler

fn verw(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmVerw<AsmRegister64> for CodeAssembler

fn verw(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmVexp2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexp2pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexp2pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vexp2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVexp2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexp2ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexp2ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vexp2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf128( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf128( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf128<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x8<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf32x8<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x4<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractf64x4<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti128( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti128( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti128<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x8<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti32x8<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x4( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x4<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextracti64x4<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vextractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vextractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn vextractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn vextractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn vextractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVextractps<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn vextractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfcmaddcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfcmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfcmulcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfcmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfcmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfcmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vfixupimmsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vfixupimmsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vfixupimmss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vfixupimmss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmadd132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmadd132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmadd132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmadd213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmadd213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmadd213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmadd231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmadd231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmadd231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddsub132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddsub132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddsub132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddsub213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddsub213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddsub213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddsub231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddsub231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmaddsub231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmaddsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsub132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsub132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsub132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsub213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsub213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsub213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsub231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsub231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsub231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsubadd132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsubadd132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsubadd132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsubadd213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsubadd213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsubadd213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsubadd231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsubadd231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmsubadd231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfmulcph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfmulcsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmadd132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmadd132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmadd132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmadd213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmadd213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmadd213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmadd231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmadd231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmadd231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmadd231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmaddsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmaddss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmsub132pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmsub132ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmsub132ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub132ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmsub213pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmsub213ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmsub213ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub213ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmsub231pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmsub231ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vfnmsub231ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231sh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsub231ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfnmsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vfnmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfnmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfnmsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterYmm, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterYmm, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterYmm, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterYmm, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterYmm, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterYmm, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfrczpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfrczpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczpd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfrczpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfrczps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vfrczps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vfrczps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVfrczsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfrczsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVfrczss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vfrczss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVfrczss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vfrczss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherdpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vgatherdpd_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgatherdps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherdps_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherdps3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vgatherdps_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherpf0dpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf0dps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf0qpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf0qps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf0qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1dpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1dps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1qpd<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherpf1qps<AsmMemoryOperand> for CodeAssembler

fn vgatherpf1qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherqpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherqpd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vgatherqpd_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgatherqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgatherqps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgatherqps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vgatherqps_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexppd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgetexpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgetexpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgetexpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgetexpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgetmantss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgetmantss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgetmantss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgetmantss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vgf2p8mulb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vhaddpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vhaddpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vhaddps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vhaddps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vhsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vhsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vhsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vhsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vhsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVhsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vhsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVlddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vlddqu( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVlddqu<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vlddqu( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVldmxcsr<AsmMemoryOperand> for CodeAssembler

fn vldmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmaskmovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovdqu( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaskmovps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaskmovps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmaxpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmaxph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmaxps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmaxss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmaxss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmaxss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmaxss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmcall for CodeAssembler

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

impl CodeAsmVmclear<AsmMemoryOperand> for CodeAssembler

fn vmclear(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmfunc for CodeAssembler

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

impl CodeAsmVmgexit for CodeAssembler

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

impl CodeAsmVminpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vminpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vminph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vminps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVminsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVminss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vminss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVminss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vminss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmlaunch for CodeAssembler

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

impl CodeAsmVmload for CodeAssembler

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

impl CodeAsmVmmcall for CodeAssembler

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

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovapd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vmovd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vmovd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovdqa( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovdqu( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovhlps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovhlps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovhpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovhpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovhpd3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovhpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovhps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovhps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovhps3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovhps_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovlhps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovlhps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovlpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovlpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovlpd3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovlpd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovlps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovlps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovlps3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovlps_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovmskpd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vmovmskpd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovmskpd<AsmRegister32, AsmRegisterYmm> for CodeAssembler

fn vmovmskpd( &mut self, op0: AsmRegister32, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovmskpd<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vmovmskpd( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovmskpd<AsmRegister64, AsmRegisterYmm> for CodeAssembler

fn vmovmskpd( &mut self, op0: AsmRegister64, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovmskps<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vmovmskps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovmskps<AsmRegister32, AsmRegisterYmm> for CodeAssembler

fn vmovmskps( &mut self, op0: AsmRegister32, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovmskps<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vmovmskps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovmskps<AsmRegister64, AsmRegisterYmm> for CodeAssembler

fn vmovmskps( &mut self, op0: AsmRegister64, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovntdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovntdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovntdqa<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovntdqa( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovntpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovntpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovntps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovntps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovntps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vmovq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vmovq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVmovq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovsd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovsd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovsd3<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovsh<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovsh( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovsh<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsh( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovsh3<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovsh_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovshdup<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovss( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovss3<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovss_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vmovw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVmovw<AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vmovw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vmpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVmptrld<AsmMemoryOperand> for CodeAssembler

fn vmptrld(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmptrst<AsmMemoryOperand> for CodeAssembler

fn vmptrst(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn vmread( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn vmread( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVmread<AsmRegister32, AsmRegister32> for CodeAssembler

fn vmread( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVmread<AsmRegister64, AsmRegister64> for CodeAssembler

fn vmread( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVmresume for CodeAssembler

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

impl CodeAsmVmrun for CodeAssembler

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

impl CodeAsmVmsave for CodeAssembler

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

impl CodeAsmVmulpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmulpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmulph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmulps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVmulsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmulsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmulss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vmulss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmulss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vmulss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVmwrite<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn vmwrite( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmwrite<AsmRegister32, AsmRegister32> for CodeAssembler

fn vmwrite( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVmwrite<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn vmwrite( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVmwrite<AsmRegister64, AsmRegister64> for CodeAssembler

fn vmwrite( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVmxoff for CodeAssembler

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

impl CodeAsmVmxon<AsmMemoryOperand> for CodeAssembler

fn vmxon(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vorpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVorps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vorps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVp4dpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp4dpwssd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVp4dpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp4dpwssds( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpackssdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpacksswb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpacksswb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackusdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpackusdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpackuswb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpackuswb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpaddb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpaddd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpaddq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpaddsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpaddsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpaddusb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddusw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpaddusw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpaddw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpaddw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpand( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpand( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpand( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpand<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpand( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpandd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandn( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandn( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandn( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandn<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpandn( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpandnd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandnq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpandnq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpandq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpandq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpavgb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpavgw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpavgw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpblendd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpblendmb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpblendmd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpblendmq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpblendmw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpblendmw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendvb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpblendvb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendvb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpblendvb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendvb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpblendvb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendvb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpblendvb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpblendw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmRegister32> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterYmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmRegister32> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterZmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmRegister32> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterYmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmRegister32> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterZmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmb2q<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmb2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmb2q<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmb2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmb2q<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmb2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmw2d<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmw2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmw2d<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmw2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmw2d<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmw2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmRegister64> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterYmm, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmRegister64> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterZmm, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmRegister32> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmRegister32> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterYmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmRegister32> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterZmm, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpbroadcastw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpclmulhqhqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmulhqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpclmulhqlqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpclmullqhqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpclmullqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpclmullqlqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmov<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmov( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomeqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomeqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomeqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomequb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomequd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomequq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomequw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomeqw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomeqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsed<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalsed( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsed<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalsed( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalseuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalseuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalseuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomfalsew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomfalsew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomfalsew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomged<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomged( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomged<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomged( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgeuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgeuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgeuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomgtw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomgtw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomleb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomled<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomled( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomled<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomled( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomleq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomleub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomleud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomleuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomleuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomleuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomleuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomleuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomlew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomlew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomlew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomlew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomltb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomltd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomltq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomltub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomltud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomltuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomltuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomltw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomltw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomltw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomltw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomneqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomneqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomneqq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomnequb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomnequd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomnequq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomnequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomnequw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomnequw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomneqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomneqw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomneqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrued<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrued( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrued<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrued( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtrueuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtrueuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtrueuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomtruew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcomtruew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpcomtruew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcomtruew( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpbssd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbssds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbssds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpbssds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpbsud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbsuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbsuds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpbsuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpdpbusd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbusds<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpdpbusds( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpbuud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpbuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpbuuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpbuuds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpbuuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpdpwssd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpdpwssds( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwsud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpwsud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwsuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwsuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwsuds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpwsuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwusd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpwusd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwusds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwusds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwusds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpwusds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwuud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpwuud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpdpwuuds( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpdpwuuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpdpwuuds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpdpwuuds( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vperm2f128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vperm2f128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vperm2f128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vperm2f128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vperm2i128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vperm2i128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vperm2i128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vperm2i128( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2b<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermi2b( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2d<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermi2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermi2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermi2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2q<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermi2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermi2w<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermi2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpermil2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: AsmRegisterYmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmMemoryOperand, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, op4: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpermil2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: AsmRegisterYmm, op4: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2b<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermt2b( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2d<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermt2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermt2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermt2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2q<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermt2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermt2w<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermt2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpermw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpermw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrb<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrd<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrq<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpextrw<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

fn vpextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherdd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpgatherdd_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherdq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherdq_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherdq3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpgatherdq_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherqd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpgatherqq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpgatherqq_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpgatherqq3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpgatherqq_3( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddbd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddbq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphaddd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vphaddd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVphadddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadddq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphadddq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphadddq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphaddsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vphaddsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddubd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddubq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddubq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddubw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddubw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddudq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddudq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddudq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddudq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphadduwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadduwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphadduwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphadduwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphadduwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphadduwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphadduwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphadduwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphaddw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vphaddw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphaddwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphaddwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphaddwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphaddwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphminposuw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphminposuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphminposuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphsubbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphsubd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vphsubd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVphsubdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphsubsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vphsubsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vphsubw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vphsubw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVphsubwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vphsubwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVphsubwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vphsubwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsdqh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdqh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsdqh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsdqh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsdql<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsdql( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsdql<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsdql( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacssdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacssdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacssdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacssdqh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdqh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacssdqh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacssdqh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacssdql<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssdql( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacssdql<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacssdql( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacssww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacssww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacssww<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacssww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmacsww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmacsww<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmacsww( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadcsswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmadcsswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadcsswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmadcsswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadcswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmadcswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadcswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmadcswd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmadd52huq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmadd52luq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmadd52luq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddubsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaddubsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaddwd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaddwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaskmovq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaskmovq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaxsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaxsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaxsq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaxsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxub<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaxub( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxud<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaxud( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaxuq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmaxuw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmaxuw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpminsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpminsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpminsq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpminsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminub<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpminub( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminud<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpminud( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpminuq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpminuw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpminuw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovb2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

fn vpmovb2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovb2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovd2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

fn vpmovd2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovd2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovdw<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2b<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2b<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpmovm2b( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2b<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2b( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2d<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2d<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpmovm2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2d<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2q<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2q<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpmovm2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2q<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2w<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2w<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpmovm2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovm2w<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK, ) -> Result<(), IcedError>

impl CodeAsmVpmovmskb<AsmRegister32, AsmRegisterXmm> for CodeAssembler

fn vpmovmskb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovmskb<AsmRegister32, AsmRegisterYmm> for CodeAssembler

fn vpmovmskb( &mut self, op0: AsmRegister32, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovmskb<AsmRegister64, AsmRegisterXmm> for CodeAssembler

fn vpmovmskb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovmskb<AsmRegister64, AsmRegisterYmm> for CodeAssembler

fn vpmovmskb( &mut self, op0: AsmRegister64, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovq2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

fn vpmovq2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovq2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqd<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsdw<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqd<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovswb<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbw<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovsxwq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusdb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusdw<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqd<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusqw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovuswb<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovw2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

fn vpmovw2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovw2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbw<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpmovzxwq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmuldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhrsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmulhrsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhuw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmulhuw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulhw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmulhw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmulld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmulld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmullq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmullw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmullw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmultishiftqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmultishiftqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpmuludq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpmuludq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpor( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpor<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpor( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVporq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vporq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpperm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpperm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpperm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprold<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprolq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vprolvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprolvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vprolvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprord<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprorq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vprorvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprorvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vprorvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterdd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterdd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpscatterdd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpscatterdq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterqd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpscatterqq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vpscatterqq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vpscatterqq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshab( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshab( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshab<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshab( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshad<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshad( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshad<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshad<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshaq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshaq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshaq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshaq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshaq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshaq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshaw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshaw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshaw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshaw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshaw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshaw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshlb<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshlb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshlb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshlb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshlb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshlb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshld<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshldvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshldvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshldvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshldvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshlq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshlq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshlq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshlq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshlw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vpshlw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshlw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshlw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshrdvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshrdvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshrdvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshrdvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshufb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsignb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsignb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsignb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsignw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsignw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsignw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsignw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsignw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpslldq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsllvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsllvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsllvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsravd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsravq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsravw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsravw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsrlvd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsrlvq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsrlvw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsubb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsubd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsubq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsubsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsubsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsubusb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubusw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsubusw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpsubw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpsubw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptest( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptest( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptest( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptest<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptest( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpunpckhbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpunpckhdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpunpckhqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckhwd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpunpckhwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpunpcklbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpckldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpunpckldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpunpcklqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpunpcklwd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpunpcklwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpxor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpxor( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxor<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpxor( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxord<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpxord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVpxorq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpxorq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp14ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp28pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcp28pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp28ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcp28ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp28sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrcp28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcp28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcp28ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcp28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrcpps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vrcpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVrcpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcpsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrcpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrcpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrcpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrcpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceph<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVreduceps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscalesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscalesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscalesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscalesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscalesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscalesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrndscaless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrndscaless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vrndscaless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vrndscaless( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundpd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt14sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt14ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28pd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrt28pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28ps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrt28ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt28sd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrt28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrt28ss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vrsqrtps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vrsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVrsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vrsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vscalefpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vscalefph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vscalefps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscalefss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vscalefss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVscalefss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vscalefss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterdpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterdpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vscatterdpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterdps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterdps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vscatterdps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterpf0dpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf0dps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf0qpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf0qps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf0qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1dpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1dpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1dps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1dps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1qpd<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1qpd(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterpf1qps<AsmMemoryOperand> for CodeAssembler

fn vscatterpf1qps(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterqpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterqpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

fn vscatterqpd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterqps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

fn vscatterqps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVscatterqps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

fn vscatterqps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsha512msg1<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vsha512msg1( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsha512msg2<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vsha512msg2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsha512rnds2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

fn vsha512rnds2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVsm3msg1<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm3msg1( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm3msg1<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsm3msg1( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsm3msg2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm3msg2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm3msg2<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsm3msg2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

impl CodeAsmVsm4key4<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm4key4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm4key4<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsm4key4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsm4key4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsm4key4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm4key4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vsm4key4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsm4rnds4<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsm4rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm4rnds4<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsm4rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsm4rnds4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsm4rnds4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsm4rnds4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vsm4rnds4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsqrtss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVstmxcsr<AsmMemoryOperand> for CodeAssembler

fn vstmxcsr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsubsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubsh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vsubss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vtestpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vtestpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vtestpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVtestpd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vtestpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vtestps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vtestps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vtestps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVtestps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vtestps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVucomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomisd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVucomisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vucomisd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVucomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomish( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVucomish<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vucomish( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVucomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vucomiss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVucomiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vucomiss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, ) -> Result<(), IcedError>

impl CodeAsmVzeroall for CodeAssembler

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

impl CodeAsmVzeroupper for CodeAssembler

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

impl CodeAsmWait for CodeAssembler

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

impl CodeAsmWbinvd for CodeAssembler

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

impl CodeAsmWbnoinvd for CodeAssembler

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

impl CodeAsmWrfsbase<AsmRegister32> for CodeAssembler

fn wrfsbase(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmWrfsbase<AsmRegister64> for CodeAssembler

fn wrfsbase(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmWrgsbase<AsmRegister32> for CodeAssembler

fn wrgsbase(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmWrgsbase<AsmRegister64> for CodeAssembler

fn wrgsbase(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

impl CodeAsmWrmsr for CodeAssembler

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

impl CodeAsmWrmsrlist for CodeAssembler

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

impl CodeAsmWrmsrns for CodeAssembler

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

impl CodeAsmWrpkru for CodeAssembler

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

impl CodeAsmWrshr<AsmMemoryOperand> for CodeAssembler

fn wrshr(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmWrshr<AsmRegister32> for CodeAssembler

fn wrshr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

impl CodeAsmWrssd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn wrssd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmWrssq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn wrssq( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmWrudbg for CodeAssembler

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

impl CodeAsmWrussd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn wrussd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmWrussq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn wrussq( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXabort<i32> for CodeAssembler

fn xabort(&mut self, op0: i32) -> Result<(), IcedError>

impl CodeAsmXabort<u32> for CodeAssembler

fn xabort(&mut self, op0: u32) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmRegister16, AsmRegister16> for CodeAssembler

fn xadd( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmRegister32, AsmRegister32> for CodeAssembler

fn xadd( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmRegister64, AsmRegister64> for CodeAssembler

fn xadd( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXadd<AsmRegister8, AsmRegister8> for CodeAssembler

fn xadd( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmXbegin<CodeLabel> for CodeAssembler

fn xbegin(&mut self, op0: CodeLabel) -> Result<(), IcedError>

impl CodeAsmXbegin<u64> for CodeAssembler

fn xbegin(&mut self, op0: u64) -> Result<(), IcedError>

impl CodeAsmXbts<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn xbts( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXbts<AsmRegister16, AsmRegister16> for CodeAssembler

fn xbts( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXbts<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn xbts( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXbts<AsmRegister32, AsmRegister32> for CodeAssembler

fn xbts( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmRegister16, AsmRegister16> for CodeAssembler

fn xchg( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmRegister32, AsmRegister32> for CodeAssembler

fn xchg( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmRegister64, AsmRegister64> for CodeAssembler

fn xchg( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXchg<AsmRegister8, AsmRegister8> for CodeAssembler

fn xchg( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmXcryptcbc for CodeAssembler

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

impl CodeAsmXcryptcfb for CodeAssembler

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

impl CodeAsmXcryptctr for CodeAssembler

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

impl CodeAsmXcryptecb for CodeAssembler

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

impl CodeAsmXcryptofb for CodeAssembler

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

impl CodeAsmXend for CodeAssembler

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

impl CodeAsmXgetbv for CodeAssembler

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

impl CodeAsmXor<AsmMemoryOperand, AsmRegister16> for CodeAssembler

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, AsmRegister8> for CodeAssembler

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, i32> for CodeAssembler

fn xor(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

impl CodeAsmXor<AsmMemoryOperand, u32> for CodeAssembler

fn xor(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister16, AsmMemoryOperand> for CodeAssembler

fn xor( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister16, AsmRegister16> for CodeAssembler

fn xor( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister16, i32> for CodeAssembler

fn xor(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister16, u32> for CodeAssembler

fn xor(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister32, AsmMemoryOperand> for CodeAssembler

fn xor( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister32, AsmRegister32> for CodeAssembler

fn xor( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister32, i32> for CodeAssembler

fn xor(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister32, u32> for CodeAssembler

fn xor(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister64, AsmMemoryOperand> for CodeAssembler

fn xor( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister64, AsmRegister64> for CodeAssembler

fn xor( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister64, i32> for CodeAssembler

fn xor(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister8, AsmMemoryOperand> for CodeAssembler

fn xor( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister8, AsmRegister8> for CodeAssembler

fn xor(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister8, i32> for CodeAssembler

fn xor(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

impl CodeAsmXor<AsmRegister8, u32> for CodeAssembler

fn xor(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

impl CodeAsmXorpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn xorpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXorpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn xorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmXorps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn xorps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

impl CodeAsmXorps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn xorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

impl CodeAsmXresldtrk for CodeAssembler

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

impl CodeAsmXrstor<AsmMemoryOperand> for CodeAssembler

fn xrstor(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXrstor64<AsmMemoryOperand> for CodeAssembler

fn xrstor64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXrstors<AsmMemoryOperand> for CodeAssembler

fn xrstors(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXrstors64<AsmMemoryOperand> for CodeAssembler

fn xrstors64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsave<AsmMemoryOperand> for CodeAssembler

fn xsave(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsave64<AsmMemoryOperand> for CodeAssembler

fn xsave64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsavec<AsmMemoryOperand> for CodeAssembler

fn xsavec(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsavec64<AsmMemoryOperand> for CodeAssembler

fn xsavec64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaveopt<AsmMemoryOperand> for CodeAssembler

fn xsaveopt(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaveopt64<AsmMemoryOperand> for CodeAssembler

fn xsaveopt64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaves<AsmMemoryOperand> for CodeAssembler

fn xsaves(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsaves64<AsmMemoryOperand> for CodeAssembler

fn xsaves64(&mut self, op0: AsmMemoryOperand) -> Result<(), IcedError>

impl CodeAsmXsetbv for CodeAssembler

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

impl CodeAsmXsha1 for CodeAssembler

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

impl CodeAsmXsha256 for CodeAssembler

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

impl CodeAsmXsha512 for CodeAssembler

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

impl CodeAsmXsha512_alt for CodeAssembler

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

impl CodeAsmXstore for CodeAssembler

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

impl CodeAsmXstore_alt for CodeAssembler

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

impl CodeAsmXsusldtrk for CodeAssembler

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

impl CodeAsmXtest for CodeAssembler

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

impl CodeAsmZero_bytes for CodeAssembler

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