Struct CodeAssembler

Source
pub struct CodeAssembler { /* private fields */ }
Expand description

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§

Source§

impl CodeAssembler

Source

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

Creates a new instance

§Errors

Fails if bitness is invalid

§Arguments
  • bitness: 16, 32, or 64
Source

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

Adds an XACQUIRE prefix to the next added instruction

Source

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

Adds an XRELEASE prefix to the next added instruction

Source

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

Adds a LOCK prefix to the next added instruction

Source

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

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

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

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

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

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

Adds a BND prefix to the next added instruction

Source

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

Adds a NOTRACK prefix to the next added instruction

Source

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

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

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)?,
]);
Source

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)?,
]);
Source

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

pub fn create_label(&mut self) -> CodeLabel

Creates a label that can be referenced by instructions

Source

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

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

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

Source

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

Source

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn bitness(&self) -> u32

Gets the bitness (16, 32 or 64)

Source

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

Source

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
Source

pub fn prefer_short_branch(&self) -> bool

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

Source

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
Source

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

CALL FAR instruction

InstructionOpcodeCPUID
CALL ptr16:16o16 9A cd8086+
CALL ptr16:32o32 9A cp386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • selector: Selector/segment
  • offset: Offset within the segment
Source

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

JMP FAR instruction

InstructionOpcodeCPUID
JMP ptr16:16o16 EA cd8086+
JMP ptr16:32o32 EA cp386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • selector: Selector/segment
  • offset: Offset within the segment
Source

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

XLATB instruction

InstructionOpcodeCPUID
XLATBD78086+
§Errors

Fails if an operand is invalid (basic checks only)

Source§

impl CodeAssembler

Source

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

AAA instruction

InstructionOpcodeCPUID
AAA378086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

AAD instruction

InstructionOpcodeCPUID
AAD imm8D5 ib8086+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AADD instruction

InstructionOpcodeCPUID
AADD m32, r32NP 0F 38 FC !(11):rrr:bbbRAO-INT
AADD m64, r64NP o64 0F 38 FC !(11):rrr:bbbRAO-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
Source

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

AAM instruction

InstructionOpcodeCPUID
AAM imm8D4 ib8086+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AAND instruction

InstructionOpcodeCPUID
AAND m32, r3266 0F 38 FC !(11):rrr:bbbRAO-INT
AAND m64, r6466 o64 0F 38 FC !(11):rrr:bbbRAO-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
Source

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

AAS instruction

InstructionOpcodeCPUID
AAS3F8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

ADC instruction

InstructionOpcodeCPUID
ADC r/m8, r810 /r8086+
ADC r/m16, r16o16 11 /r8086+
ADC r/m32, r32o32 11 /r386+
ADC r/m64, r64o64 11 /rX64
ADC r8, r/m812 /r8086+
ADC r16, r/m16o16 13 /r8086+
ADC r32, r/m32o32 13 /r386+
ADC r64, r/m64o64 13 /rX64
ADC AL, imm814 ib8086+
ADC AX, imm16o16 15 iw8086+
ADC EAX, imm32o32 15 id386+
ADC RAX, imm32o64 15 idX64
ADC r/m8, imm880 /2 ib8086+
ADC r/m16, imm16o16 81 /2 iw8086+
ADC r/m32, imm32o32 81 /2 id386+
ADC r/m64, imm32o64 81 /2 idX64
ADC r/m16, imm8o16 83 /2 ib8086+
ADC r/m32, imm8o32 83 /2 ib386+
ADC r/m64, imm8o64 83 /2 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ADCX instruction

InstructionOpcodeCPUID
ADCX r32, r/m3266 0F 38 F6 /rADX
ADCX r64, r/m6466 o64 0F 38 F6 /rADX
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ADD instruction

InstructionOpcodeCPUID
ADD r/m8, r800 /r8086+
ADD r/m16, r16o16 01 /r8086+
ADD r/m32, r32o32 01 /r386+
ADD r/m64, r64o64 01 /rX64
ADD r8, r/m802 /r8086+
ADD r16, r/m16o16 03 /r8086+
ADD r32, r/m32o32 03 /r386+
ADD r64, r/m64o64 03 /rX64
ADD AL, imm804 ib8086+
ADD AX, imm16o16 05 iw8086+
ADD EAX, imm32o32 05 id386+
ADD RAX, imm32o64 05 idX64
ADD r/m8, imm880 /0 ib8086+
ADD r/m16, imm16o16 81 /0 iw8086+
ADD r/m32, imm32o32 81 /0 id386+
ADD r/m64, imm32o64 81 /0 idX64
ADD r/m16, imm8o16 83 /0 ib8086+
ADD r/m32, imm8o32 83 /0 ib386+
ADD r/m64, imm8o64 83 /0 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ADDPD instruction

InstructionOpcodeCPUID
ADDPD xmm1, xmm2/m12866 0F 58 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ADDPS instruction

InstructionOpcodeCPUID
ADDPS xmm1, xmm2/m128NP 0F 58 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ADDSD instruction

InstructionOpcodeCPUID
ADDSD xmm1, xmm2/m64F2 0F 58 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ADDSS instruction

InstructionOpcodeCPUID
ADDSS xmm1, xmm2/m32F3 0F 58 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ADDSUBPD instruction

InstructionOpcodeCPUID
ADDSUBPD xmm1, xmm2/m12866 0F D0 /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ADDSUBPS instruction

InstructionOpcodeCPUID
ADDSUBPS xmm1, xmm2/m128F2 0F D0 /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ADOX instruction

InstructionOpcodeCPUID
ADOX r32, r/m32F3 0F 38 F6 /rADX
ADOX r64, r/m64F3 o64 0F 38 F6 /rADX
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESDEC instruction

InstructionOpcodeCPUID
AESDEC xmm1, xmm2/m12866 0F 38 DE /rAES
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESDEC128KL instruction

InstructionOpcodeCPUID
AESDEC128KL xmm, m384F3 0F 38 DD !(11):rrr:bbbAESKLE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESDEC256KL instruction

InstructionOpcodeCPUID
AESDEC256KL xmm, m512F3 0F 38 DF !(11):rrr:bbbAESKLE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESDECLAST instruction

InstructionOpcodeCPUID
AESDECLAST xmm1, xmm2/m12866 0F 38 DF /rAES
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESDECWIDE128KL instruction

InstructionOpcodeCPUID
AESDECWIDE128KL m384, <XMM0-7>F3 0F 38 D8 !(11):001:bbbAESKLE 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)
Source

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

AESDECWIDE256KL instruction

InstructionOpcodeCPUID
AESDECWIDE256KL m512, <XMM0-7>F3 0F 38 D8 !(11):011:bbbAESKLE 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)
Source

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

AESENC instruction

InstructionOpcodeCPUID
AESENC xmm1, xmm2/m12866 0F 38 DC /rAES
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESENC128KL instruction

InstructionOpcodeCPUID
AESENC128KL xmm, m384F3 0F 38 DC !(11):rrr:bbbAESKLE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESENC256KL instruction

InstructionOpcodeCPUID
AESENC256KL xmm, m512F3 0F 38 DE !(11):rrr:bbbAESKLE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESENCLAST instruction

InstructionOpcodeCPUID
AESENCLAST xmm1, xmm2/m12866 0F 38 DD /rAES
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESENCWIDE128KL instruction

InstructionOpcodeCPUID
AESENCWIDE128KL m384, <XMM0-7>F3 0F 38 D8 !(11):000:bbbAESKLE 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)
Source

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

AESENCWIDE256KL instruction

InstructionOpcodeCPUID
AESENCWIDE256KL m512, <XMM0-7>F3 0F 38 D8 !(11):010:bbbAESKLE 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)
Source

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

AESIMC instruction

InstructionOpcodeCPUID
AESIMC xmm1, xmm2/m12866 0F 38 DB /rAES
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AESKEYGENASSIST instruction

InstructionOpcodeCPUID
AESKEYGENASSIST xmm1, xmm2/m128, imm866 0F 3A DF /r ibAES
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ALTINST instruction

InstructionOpcodeCPUID
ALTINST0F 3FCentaur AIS
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

AND instruction

InstructionOpcodeCPUID
AND r/m8, r820 /r8086+
AND r/m16, r16o16 21 /r8086+
AND r/m32, r32o32 21 /r386+
AND r/m64, r64o64 21 /rX64
AND r8, r/m822 /r8086+
AND r16, r/m16o16 23 /r8086+
AND r32, r/m32o32 23 /r386+
AND r64, r/m64o64 23 /rX64
AND AL, imm824 ib8086+
AND AX, imm16o16 25 iw8086+
AND EAX, imm32o32 25 id386+
AND RAX, imm32o64 25 idX64
AND r/m8, imm880 /4 ib8086+
AND r/m16, imm16o16 81 /4 iw8086+
AND r/m32, imm32o32 81 /4 id386+
AND r/m64, imm32o64 81 /4 idX64
AND r/m16, imm8o16 83 /4 ib8086+
AND r/m32, imm8o32 83 /4 ib386+
AND r/m64, imm8o64 83 /4 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ANDN instruction

InstructionOpcodeCPUID
ANDN r32a, r32b, r/m32VEX.LZ.0F38.W0 F2 /rBMI1
ANDN r64a, r64b, r/m64VEX.LZ.0F38.W1 F2 /rBMI1
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ANDNPD instruction

InstructionOpcodeCPUID
ANDNPD xmm1, xmm2/m12866 0F 55 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ANDNPS instruction

InstructionOpcodeCPUID
ANDNPS xmm1, xmm2/m128NP 0F 55 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ANDPD instruction

InstructionOpcodeCPUID
ANDPD xmm1, xmm2/m12866 0F 54 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ANDPS instruction

InstructionOpcodeCPUID
ANDPS xmm1, xmm2/m128NP 0F 54 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AOR instruction

InstructionOpcodeCPUID
AOR m32, r32F2 0F 38 FC !(11):rrr:bbbRAO-INT
AOR m64, r64F2 o64 0F 38 FC !(11):rrr:bbbRAO-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
Source

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

ARPL instruction

InstructionOpcodeCPUID
ARPL r/m16, r16o16 63 /r286+
ARPL r32/m16, r32o32 63 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

AXOR instruction

InstructionOpcodeCPUID
AXOR m32, r32F3 0F 38 FC !(11):rrr:bbbRAO-INT
AXOR m64, r64F3 o64 0F 38 FC !(11):rrr:bbbRAO-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
Source

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

BB0_RESET instruction

InstructionOpcodeCPUID
BB0_RESET0F 3ACyrix MediaGX, GXm, GXLV, GX1
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

BB1_RESET instruction

InstructionOpcodeCPUID
BB1_RESET0F 3BCyrix MediaGX, GXm, GXLV, GX1
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

BEXTR instruction

InstructionOpcodeCPUID
BEXTR r32a, r/m32, r32bVEX.LZ.0F38.W0 F7 /rBMI1
BEXTR r64a, r/m64, r64bVEX.LZ.0F38.W1 F7 /rBMI1
BEXTR r32, r/m32, imm32XOP.L0.XA.W0 10 /r idTBM
BEXTR r64, r/m64, imm32XOP.L0.XA.W1 10 /r idTBM
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLCFILL instruction

InstructionOpcodeCPUID
BLCFILL r32, r/m32XOP.L0.X9.W0 01 /1TBM
BLCFILL r64, r/m64XOP.L0.X9.W1 01 /1TBM
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLCI instruction

InstructionOpcodeCPUID
BLCI r32, r/m32XOP.L0.X9.W0 02 /6TBM
BLCI r64, r/m64XOP.L0.X9.W1 02 /6TBM
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLCIC instruction

InstructionOpcodeCPUID
BLCIC r32, r/m32XOP.L0.X9.W0 01 /5TBM
BLCIC r64, r/m64XOP.L0.X9.W1 01 /5TBM
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLCMSK instruction

InstructionOpcodeCPUID
BLCMSK r32, r/m32XOP.L0.X9.W0 02 /1TBM
BLCMSK r64, r/m64XOP.L0.X9.W1 02 /1TBM
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLCS instruction

InstructionOpcodeCPUID
BLCS r32, r/m32XOP.L0.X9.W0 01 /3TBM
BLCS r64, r/m64XOP.L0.X9.W1 01 /3TBM
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLENDPD instruction

InstructionOpcodeCPUID
BLENDPD xmm1, xmm2/m128, imm866 0F 3A 0D /r ibSSE4.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
Source

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

BLENDPS instruction

InstructionOpcodeCPUID
BLENDPS xmm1, xmm2/m128, imm866 0F 3A 0C /r ibSSE4.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
Source

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

BLENDVPD instruction

InstructionOpcodeCPUID
BLENDVPD xmm1, xmm2/m128, <XMM0>66 0F 38 15 /rSSE4.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
Source

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

BLENDVPS instruction

InstructionOpcodeCPUID
BLENDVPS xmm1, xmm2/m128, <XMM0>66 0F 38 14 /rSSE4.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
Source

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

BLSFILL instruction

InstructionOpcodeCPUID
BLSFILL r32, r/m32XOP.L0.X9.W0 01 /2TBM
BLSFILL r64, r/m64XOP.L0.X9.W1 01 /2TBM
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLSI instruction

InstructionOpcodeCPUID
BLSI r32, r/m32VEX.LZ.0F38.W0 F3 /3BMI1
BLSI r64, r/m64VEX.LZ.0F38.W1 F3 /3BMI1
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLSIC instruction

InstructionOpcodeCPUID
BLSIC r32, r/m32XOP.L0.X9.W0 01 /6TBM
BLSIC r64, r/m64XOP.L0.X9.W1 01 /6TBM
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLSMSK instruction

InstructionOpcodeCPUID
BLSMSK r32, r/m32VEX.LZ.0F38.W0 F3 /2BMI1
BLSMSK r64, r/m64VEX.LZ.0F38.W1 F3 /2BMI1
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BLSR instruction

InstructionOpcodeCPUID
BLSR r32, r/m32VEX.LZ.0F38.W0 F3 /1BMI1
BLSR r64, r/m64VEX.LZ.0F38.W1 F3 /1BMI1
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BNDCL instruction

InstructionOpcodeCPUID
BNDCL bnd, r/m32F3 0F 1A /rMPX
BNDCL bnd, r/m64F3 0F 1A /rMPX
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BNDCN instruction

InstructionOpcodeCPUID
BNDCN bnd, r/m32F2 0F 1B /rMPX
BNDCN bnd, r/m64F2 0F 1B /rMPX
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BNDCU instruction

InstructionOpcodeCPUID
BNDCU bnd, r/m32F2 0F 1A /rMPX
BNDCU bnd, r/m64F2 0F 1A /rMPX
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BNDLDX instruction

InstructionOpcodeCPUID
BNDLDX bnd, mibNP 0F 1A /rMPX
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BNDMK instruction

InstructionOpcodeCPUID
BNDMK bnd, m32F3 0F 1B /rMPX
BNDMK bnd, m64F3 0F 1B /rMPX
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BNDMOV instruction

InstructionOpcodeCPUID
BNDMOV bnd1, bnd2/m6466 0F 1A /rMPX
BNDMOV bnd1, bnd2/m12866 0F 1A /rMPX
BNDMOV bnd1/m64, bnd266 0F 1B /rMPX
BNDMOV bnd1/m128, bnd266 0F 1B /rMPX
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BNDSTX instruction

InstructionOpcodeCPUID
BNDSTX mib, bndNP 0F 1B /rMPX
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BOUND instruction

InstructionOpcodeCPUID
BOUND r16, m16&16o16 62 /r186+
BOUND r32, m32&32o32 62 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BSF instruction

InstructionOpcodeCPUID
BSF r16, r/m16o16 0F BC /r386+
BSF r32, r/m32o32 0F BC /r386+
BSF r64, r/m64o64 0F BC /rX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BSR instruction

InstructionOpcodeCPUID
BSR r16, r/m16o16 0F BD /r386+
BSR r32, r/m32o32 0F BD /r386+
BSR r64, r/m64o64 0F BD /rX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BSWAP instruction

InstructionOpcodeCPUID
BSWAP r16o16 0F C8+rw486+
BSWAP r32o32 0F C8+rd486+
BSWAP r64o64 0F C8+roX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BT instruction

InstructionOpcodeCPUID
BT r/m16, r16o16 0F A3 /r386+
BT r/m32, r32o32 0F A3 /r386+
BT r/m64, r64o64 0F A3 /rX64
BT r/m16, imm8o16 0F BA /4 ib386+
BT r/m32, imm8o32 0F BA /4 ib386+
BT r/m64, imm8o64 0F BA /4 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BTC instruction

InstructionOpcodeCPUID
BTC r/m16, imm8o16 0F BA /7 ib386+
BTC r/m32, imm8o32 0F BA /7 ib386+
BTC r/m64, imm8o64 0F BA /7 ibX64
BTC r/m16, r16o16 0F BB /r386+
BTC r/m32, r32o32 0F BB /r386+
BTC r/m64, r64o64 0F BB /rX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BTR instruction

InstructionOpcodeCPUID
BTR r/m16, r16o16 0F B3 /r386+
BTR r/m32, r32o32 0F B3 /r386+
BTR r/m64, r64o64 0F B3 /rX64
BTR r/m16, imm8o16 0F BA /6 ib386+
BTR r/m32, imm8o32 0F BA /6 ib386+
BTR r/m64, imm8o64 0F BA /6 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BTS instruction

InstructionOpcodeCPUID
BTS r/m16, r16o16 0F AB /r386+
BTS r/m32, r32o32 0F AB /r386+
BTS r/m64, r64o64 0F AB /rX64
BTS r/m16, imm8o16 0F BA /5 ib386+
BTS r/m32, imm8o32 0F BA /5 ib386+
BTS r/m64, imm8o64 0F BA /5 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

BZHI instruction

InstructionOpcodeCPUID
BZHI r32a, r/m32, r32bVEX.LZ.0F38.W0 F5 /rBMI2
BZHI r64a, r/m64, r64bVEX.LZ.0F38.W1 F5 /rBMI2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CALL instruction

InstructionOpcodeCPUID
CALL rel16o16 E8 cw8086+
CALL rel32o32 E8 cd386+
CALL rel32o64 E8 cdX64
CALL r/m16o16 FF /28086+
CALL r/m32o32 FF /2386+
CALL r/m64o64 FF /2X64
CALL m16:16o16 FF /38086+
CALL m16:32o32 FF /3386+
CALL m16:64o64 FF /3X64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CBW instruction

InstructionOpcodeCPUID
CBWo16 988086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CCS_ENCRYPT instruction

InstructionOpcodeCPUID
CCS_ENCRYPTa16 F3 0F A7 F0PADLOCK_GMI
CCS_ENCRYPTa32 F3 0F A7 F0PADLOCK_GMI
CCS_ENCRYPTa64 F3 0F A7 F0PADLOCK_GMI
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CCS_HASH instruction

InstructionOpcodeCPUID
CCS_HASHa16 F3 0F A6 E8PADLOCK_GMI
CCS_HASHa32 F3 0F A6 E8PADLOCK_GMI
CCS_HASHa64 F3 0F A6 E8PADLOCK_GMI
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CDQ instruction

InstructionOpcodeCPUID
CDQo32 99386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CDQE instruction

InstructionOpcodeCPUID
CDQEo64 98X64
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CL1INVMB instruction

InstructionOpcodeCPUID
CL1INVMB0F 0ACL1INVMB
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CLAC instruction

InstructionOpcodeCPUID
CLACNP 0F 01 CASMAP
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CLC instruction

InstructionOpcodeCPUID
CLCF88086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CLD instruction

InstructionOpcodeCPUID
CLDFC8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CLDEMOTE instruction

InstructionOpcodeCPUID
CLDEMOTE m8NP 0F 1C /0CLDEMOTE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CLFLUSH instruction

InstructionOpcodeCPUID
CLFLUSH m8NP 0F AE /7CLFSH
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CLFLUSHOPT instruction

InstructionOpcodeCPUID
CLFLUSHOPT m866 0F AE /7CLFLUSHOPT
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CLGI instruction

InstructionOpcodeCPUID
CLGI0F 01 DDSVM
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CLI instruction

InstructionOpcodeCPUID
CLIFA8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CLRSSBSY instruction

InstructionOpcodeCPUID
CLRSSBSY m64F3 0F AE /6CET_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)
Source

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

CLTS instruction

InstructionOpcodeCPUID
CLTS0F 06286+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CLUI instruction

InstructionOpcodeCPUID
CLUIF3 0F 01 EEUINTR
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CLWB instruction

InstructionOpcodeCPUID
CLWB m866 0F AE /6CLWB
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CLZERO instruction

InstructionOpcodeCPUID
CLZEROa16 0F 01 FCCLZERO
CLZEROa32 0F 01 FCCLZERO
CLZEROa64 0F 01 FCCLZERO
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CMC instruction

InstructionOpcodeCPUID
CMCF58086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CMOVA instruction

InstructionOpcodeCPUID
CMOVA r16, r/m16o16 0F 47 /rCMOV
CMOVA r32, r/m32o32 0F 47 /rCMOV
CMOVA r64, r/m64o64 0F 47 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVAE instruction

InstructionOpcodeCPUID
CMOVAE r16, r/m16o16 0F 43 /rCMOV
CMOVAE r32, r/m32o32 0F 43 /rCMOV
CMOVAE r64, r/m64o64 0F 43 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVB instruction

InstructionOpcodeCPUID
CMOVB r16, r/m16o16 0F 42 /rCMOV
CMOVB r32, r/m32o32 0F 42 /rCMOV
CMOVB r64, r/m64o64 0F 42 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVBE instruction

InstructionOpcodeCPUID
CMOVBE r16, r/m16o16 0F 46 /rCMOV
CMOVBE r32, r/m32o32 0F 46 /rCMOV
CMOVBE r64, r/m64o64 0F 46 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVC instruction

InstructionOpcodeCPUID
CMOVB r16, r/m16o16 0F 42 /rCMOV
CMOVB r32, r/m32o32 0F 42 /rCMOV
CMOVB r64, r/m64o64 0F 42 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVE instruction

InstructionOpcodeCPUID
CMOVE r16, r/m16o16 0F 44 /rCMOV
CMOVE r32, r/m32o32 0F 44 /rCMOV
CMOVE r64, r/m64o64 0F 44 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVG instruction

InstructionOpcodeCPUID
CMOVG r16, r/m16o16 0F 4F /rCMOV
CMOVG r32, r/m32o32 0F 4F /rCMOV
CMOVG r64, r/m64o64 0F 4F /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVGE instruction

InstructionOpcodeCPUID
CMOVGE r16, r/m16o16 0F 4D /rCMOV
CMOVGE r32, r/m32o32 0F 4D /rCMOV
CMOVGE r64, r/m64o64 0F 4D /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVL instruction

InstructionOpcodeCPUID
CMOVL r16, r/m16o16 0F 4C /rCMOV
CMOVL r32, r/m32o32 0F 4C /rCMOV
CMOVL r64, r/m64o64 0F 4C /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVLE instruction

InstructionOpcodeCPUID
CMOVLE r16, r/m16o16 0F 4E /rCMOV
CMOVLE r32, r/m32o32 0F 4E /rCMOV
CMOVLE r64, r/m64o64 0F 4E /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNA instruction

InstructionOpcodeCPUID
CMOVBE r16, r/m16o16 0F 46 /rCMOV
CMOVBE r32, r/m32o32 0F 46 /rCMOV
CMOVBE r64, r/m64o64 0F 46 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNAE instruction

InstructionOpcodeCPUID
CMOVB r16, r/m16o16 0F 42 /rCMOV
CMOVB r32, r/m32o32 0F 42 /rCMOV
CMOVB r64, r/m64o64 0F 42 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNB instruction

InstructionOpcodeCPUID
CMOVAE r16, r/m16o16 0F 43 /rCMOV
CMOVAE r32, r/m32o32 0F 43 /rCMOV
CMOVAE r64, r/m64o64 0F 43 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNBE instruction

InstructionOpcodeCPUID
CMOVA r16, r/m16o16 0F 47 /rCMOV
CMOVA r32, r/m32o32 0F 47 /rCMOV
CMOVA r64, r/m64o64 0F 47 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNC instruction

InstructionOpcodeCPUID
CMOVAE r16, r/m16o16 0F 43 /rCMOV
CMOVAE r32, r/m32o32 0F 43 /rCMOV
CMOVAE r64, r/m64o64 0F 43 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNE instruction

InstructionOpcodeCPUID
CMOVNE r16, r/m16o16 0F 45 /rCMOV
CMOVNE r32, r/m32o32 0F 45 /rCMOV
CMOVNE r64, r/m64o64 0F 45 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNG instruction

InstructionOpcodeCPUID
CMOVLE r16, r/m16o16 0F 4E /rCMOV
CMOVLE r32, r/m32o32 0F 4E /rCMOV
CMOVLE r64, r/m64o64 0F 4E /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNGE instruction

InstructionOpcodeCPUID
CMOVL r16, r/m16o16 0F 4C /rCMOV
CMOVL r32, r/m32o32 0F 4C /rCMOV
CMOVL r64, r/m64o64 0F 4C /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNL instruction

InstructionOpcodeCPUID
CMOVGE r16, r/m16o16 0F 4D /rCMOV
CMOVGE r32, r/m32o32 0F 4D /rCMOV
CMOVGE r64, r/m64o64 0F 4D /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNLE instruction

InstructionOpcodeCPUID
CMOVG r16, r/m16o16 0F 4F /rCMOV
CMOVG r32, r/m32o32 0F 4F /rCMOV
CMOVG r64, r/m64o64 0F 4F /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNO instruction

InstructionOpcodeCPUID
CMOVNO r16, r/m16o16 0F 41 /rCMOV
CMOVNO r32, r/m32o32 0F 41 /rCMOV
CMOVNO r64, r/m64o64 0F 41 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNP instruction

InstructionOpcodeCPUID
CMOVNP r16, r/m16o16 0F 4B /rCMOV
CMOVNP r32, r/m32o32 0F 4B /rCMOV
CMOVNP r64, r/m64o64 0F 4B /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNS instruction

InstructionOpcodeCPUID
CMOVNS r16, r/m16o16 0F 49 /rCMOV
CMOVNS r32, r/m32o32 0F 49 /rCMOV
CMOVNS r64, r/m64o64 0F 49 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVNZ instruction

InstructionOpcodeCPUID
CMOVNE r16, r/m16o16 0F 45 /rCMOV
CMOVNE r32, r/m32o32 0F 45 /rCMOV
CMOVNE r64, r/m64o64 0F 45 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVO instruction

InstructionOpcodeCPUID
CMOVO r16, r/m16o16 0F 40 /rCMOV
CMOVO r32, r/m32o32 0F 40 /rCMOV
CMOVO r64, r/m64o64 0F 40 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVP instruction

InstructionOpcodeCPUID
CMOVP r16, r/m16o16 0F 4A /rCMOV
CMOVP r32, r/m32o32 0F 4A /rCMOV
CMOVP r64, r/m64o64 0F 4A /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVPE instruction

InstructionOpcodeCPUID
CMOVP r16, r/m16o16 0F 4A /rCMOV
CMOVP r32, r/m32o32 0F 4A /rCMOV
CMOVP r64, r/m64o64 0F 4A /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVPO instruction

InstructionOpcodeCPUID
CMOVNP r16, r/m16o16 0F 4B /rCMOV
CMOVNP r32, r/m32o32 0F 4B /rCMOV
CMOVNP r64, r/m64o64 0F 4B /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVS instruction

InstructionOpcodeCPUID
CMOVS r16, r/m16o16 0F 48 /rCMOV
CMOVS r32, r/m32o32 0F 48 /rCMOV
CMOVS r64, r/m64o64 0F 48 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMOVZ instruction

InstructionOpcodeCPUID
CMOVE r16, r/m16o16 0F 44 /rCMOV
CMOVE r32, r/m32o32 0F 44 /rCMOV
CMOVE r64, r/m64o64 0F 44 /rCMOV
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMP instruction

InstructionOpcodeCPUID
CMP r/m8, r838 /r8086+
CMP r/m16, r16o16 39 /r8086+
CMP r/m32, r32o32 39 /r386+
CMP r/m64, r64o64 39 /rX64
CMP r8, r/m83A /r8086+
CMP r16, r/m16o16 3B /r8086+
CMP r32, r/m32o32 3B /r386+
CMP r64, r/m64o64 3B /rX64
CMP AL, imm83C ib8086+
CMP AX, imm16o16 3D iw8086+
CMP EAX, imm32o32 3D id386+
CMP RAX, imm32o64 3D idX64
CMP r/m8, imm880 /7 ib8086+
CMP r/m16, imm16o16 81 /7 iw8086+
CMP r/m32, imm32o32 81 /7 id386+
CMP r/m64, imm32o64 81 /7 idX64
CMP r/m16, imm8o16 83 /7 ib8086+
CMP r/m32, imm8o32 83 /7 ib386+
CMP r/m64, imm8o64 83 /7 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPBEXADD instruction

InstructionOpcodeCPUID
CMPBEXADD m32, r32, r32VEX.128.66.0F38.W0 E6 !(11):rrr:bbbCMPCCXADD
CMPBEXADD m64, r64, r64VEX.128.66.0F38.W1 E6 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPBXADD instruction

InstructionOpcodeCPUID
CMPBXADD m32, r32, r32VEX.128.66.0F38.W0 E2 !(11):rrr:bbbCMPCCXADD
CMPBXADD m64, r64, r64VEX.128.66.0F38.W1 E2 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPCXADD instruction

InstructionOpcodeCPUID
CMPBXADD m32, r32, r32VEX.128.66.0F38.W0 E2 !(11):rrr:bbbCMPCCXADD
CMPBXADD m64, r64, r64VEX.128.66.0F38.W1 E2 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPEQPD instruction

InstructionOpcodeCPUID
CMPPD xmm1, xmm2/m128, imm866 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPEQPS instruction

InstructionOpcodeCPUID
CMPPS xmm1, xmm2/m128, imm8NP 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPEQSD instruction

InstructionOpcodeCPUID
CMPSD xmm1, xmm2/m64, imm8F2 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPEQSS instruction

InstructionOpcodeCPUID
CMPSS xmm1, xmm2/m32, imm8F3 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLEPD instruction

InstructionOpcodeCPUID
CMPPD xmm1, xmm2/m128, imm866 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLEPS instruction

InstructionOpcodeCPUID
CMPPS xmm1, xmm2/m128, imm8NP 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLESD instruction

InstructionOpcodeCPUID
CMPSD xmm1, xmm2/m64, imm8F2 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLESS instruction

InstructionOpcodeCPUID
CMPSS xmm1, xmm2/m32, imm8F3 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLEXADD instruction

InstructionOpcodeCPUID
CMPLEXADD m32, r32, r32VEX.128.66.0F38.W0 EE !(11):rrr:bbbCMPCCXADD
CMPLEXADD m64, r64, r64VEX.128.66.0F38.W1 EE !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLTPD instruction

InstructionOpcodeCPUID
CMPPD xmm1, xmm2/m128, imm866 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLTPS instruction

InstructionOpcodeCPUID
CMPPS xmm1, xmm2/m128, imm8NP 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLTSD instruction

InstructionOpcodeCPUID
CMPSD xmm1, xmm2/m64, imm8F2 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLTSS instruction

InstructionOpcodeCPUID
CMPSS xmm1, xmm2/m32, imm8F3 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPLXADD instruction

InstructionOpcodeCPUID
CMPLXADD m32, r32, r32VEX.128.66.0F38.W0 EC !(11):rrr:bbbCMPCCXADD
CMPLXADD m64, r64, r64VEX.128.66.0F38.W1 EC !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNAEXADD instruction

InstructionOpcodeCPUID
CMPBXADD m32, r32, r32VEX.128.66.0F38.W0 E2 !(11):rrr:bbbCMPCCXADD
CMPBXADD m64, r64, r64VEX.128.66.0F38.W1 E2 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNAXADD instruction

InstructionOpcodeCPUID
CMPBEXADD m32, r32, r32VEX.128.66.0F38.W0 E6 !(11):rrr:bbbCMPCCXADD
CMPBEXADD m64, r64, r64VEX.128.66.0F38.W1 E6 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNBEXADD instruction

InstructionOpcodeCPUID
CMPNBEXADD m32, r32, r32VEX.128.66.0F38.W0 E7 !(11):rrr:bbbCMPCCXADD
CMPNBEXADD m64, r64, r64VEX.128.66.0F38.W1 E7 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNBXADD instruction

InstructionOpcodeCPUID
CMPNBXADD m32, r32, r32VEX.128.66.0F38.W0 E3 !(11):rrr:bbbCMPCCXADD
CMPNBXADD m64, r64, r64VEX.128.66.0F38.W1 E3 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNCXADD instruction

InstructionOpcodeCPUID
CMPNBXADD m32, r32, r32VEX.128.66.0F38.W0 E3 !(11):rrr:bbbCMPCCXADD
CMPNBXADD m64, r64, r64VEX.128.66.0F38.W1 E3 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNEQPD instruction

InstructionOpcodeCPUID
CMPPD xmm1, xmm2/m128, imm866 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNEQPS instruction

InstructionOpcodeCPUID
CMPPS xmm1, xmm2/m128, imm8NP 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNEQSD instruction

InstructionOpcodeCPUID
CMPSD xmm1, xmm2/m64, imm8F2 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNEQSS instruction

InstructionOpcodeCPUID
CMPSS xmm1, xmm2/m32, imm8F3 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNGEXADD instruction

InstructionOpcodeCPUID
CMPLXADD m32, r32, r32VEX.128.66.0F38.W0 EC !(11):rrr:bbbCMPCCXADD
CMPLXADD m64, r64, r64VEX.128.66.0F38.W1 EC !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNGXADD instruction

InstructionOpcodeCPUID
CMPLEXADD m32, r32, r32VEX.128.66.0F38.W0 EE !(11):rrr:bbbCMPCCXADD
CMPLEXADD m64, r64, r64VEX.128.66.0F38.W1 EE !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLEPD instruction

InstructionOpcodeCPUID
CMPPD xmm1, xmm2/m128, imm866 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLEPS instruction

InstructionOpcodeCPUID
CMPPS xmm1, xmm2/m128, imm8NP 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLESD instruction

InstructionOpcodeCPUID
CMPSD xmm1, xmm2/m64, imm8F2 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLESS instruction

InstructionOpcodeCPUID
CMPSS xmm1, xmm2/m32, imm8F3 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLEXADD instruction

InstructionOpcodeCPUID
CMPNLEXADD m32, r32, r32VEX.128.66.0F38.W0 EF !(11):rrr:bbbCMPCCXADD
CMPNLEXADD m64, r64, r64VEX.128.66.0F38.W1 EF !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLTPD instruction

InstructionOpcodeCPUID
CMPPD xmm1, xmm2/m128, imm866 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLTPS instruction

InstructionOpcodeCPUID
CMPPS xmm1, xmm2/m128, imm8NP 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLTSD instruction

InstructionOpcodeCPUID
CMPSD xmm1, xmm2/m64, imm8F2 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLTSS instruction

InstructionOpcodeCPUID
CMPSS xmm1, xmm2/m32, imm8F3 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNLXADD instruction

InstructionOpcodeCPUID
CMPNLXADD m32, r32, r32VEX.128.66.0F38.W0 ED !(11):rrr:bbbCMPCCXADD
CMPNLXADD m64, r64, r64VEX.128.66.0F38.W1 ED !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNOXADD instruction

InstructionOpcodeCPUID
CMPNOXADD m32, r32, r32VEX.128.66.0F38.W0 E1 !(11):rrr:bbbCMPCCXADD
CMPNOXADD m64, r64, r64VEX.128.66.0F38.W1 E1 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNPXADD instruction

InstructionOpcodeCPUID
CMPNPXADD m32, r32, r32VEX.128.66.0F38.W0 EB !(11):rrr:bbbCMPCCXADD
CMPNPXADD m64, r64, r64VEX.128.66.0F38.W1 EB !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNSXADD instruction

InstructionOpcodeCPUID
CMPNSXADD m32, r32, r32VEX.128.66.0F38.W0 E9 !(11):rrr:bbbCMPCCXADD
CMPNSXADD m64, r64, r64VEX.128.66.0F38.W1 E9 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPNZXADD instruction

InstructionOpcodeCPUID
CMPNZXADD m32, r32, r32VEX.128.66.0F38.W0 E5 !(11):rrr:bbbCMPCCXADD
CMPNZXADD m64, r64, r64VEX.128.66.0F38.W1 E5 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPORDPD instruction

InstructionOpcodeCPUID
CMPPD xmm1, xmm2/m128, imm866 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPORDPS instruction

InstructionOpcodeCPUID
CMPPS xmm1, xmm2/m128, imm8NP 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPORDSD instruction

InstructionOpcodeCPUID
CMPSD xmm1, xmm2/m64, imm8F2 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPORDSS instruction

InstructionOpcodeCPUID
CMPSS xmm1, xmm2/m32, imm8F3 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPOXADD instruction

InstructionOpcodeCPUID
CMPOXADD m32, r32, r32VEX.128.66.0F38.W0 E0 !(11):rrr:bbbCMPCCXADD
CMPOXADD m64, r64, r64VEX.128.66.0F38.W1 E0 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPPD instruction

InstructionOpcodeCPUID
CMPPD xmm1, xmm2/m128, imm866 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPPEXADD instruction

InstructionOpcodeCPUID
CMPPXADD m32, r32, r32VEX.128.66.0F38.W0 EA !(11):rrr:bbbCMPCCXADD
CMPPXADD m64, r64, r64VEX.128.66.0F38.W1 EA !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPPOXADD instruction

InstructionOpcodeCPUID
CMPNPXADD m32, r32, r32VEX.128.66.0F38.W0 EB !(11):rrr:bbbCMPCCXADD
CMPNPXADD m64, r64, r64VEX.128.66.0F38.W1 EB !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPPS instruction

InstructionOpcodeCPUID
CMPPS xmm1, xmm2/m128, imm8NP 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPPXADD instruction

InstructionOpcodeCPUID
CMPPXADD m32, r32, r32VEX.128.66.0F38.W0 EA !(11):rrr:bbbCMPCCXADD
CMPPXADD m64, r64, r64VEX.128.66.0F38.W1 EA !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPSB instruction

InstructionOpcodeCPUID
CMPSBA68086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CMPSD instruction

InstructionOpcodeCPUID
CMPSDo32 A7386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

InstructionOpcodeCPUID
CMPSD xmm1, xmm2/m64, imm8F2 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPSQ instruction

InstructionOpcodeCPUID
CMPSQo64 A7X64
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CMPSS instruction

InstructionOpcodeCPUID
CMPSS xmm1, xmm2/m32, imm8F3 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPSW instruction

InstructionOpcodeCPUID
CMPSWo16 A78086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CMPSXADD instruction

InstructionOpcodeCPUID
CMPSXADD m32, r32, r32VEX.128.66.0F38.W0 E8 !(11):rrr:bbbCMPCCXADD
CMPSXADD m64, r64, r64VEX.128.66.0F38.W1 E8 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPUNORDPD instruction

InstructionOpcodeCPUID
CMPPD xmm1, xmm2/m128, imm866 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPUNORDPS instruction

InstructionOpcodeCPUID
CMPPS xmm1, xmm2/m128, imm8NP 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPUNORDSD instruction

InstructionOpcodeCPUID
CMPSD xmm1, xmm2/m64, imm8F2 0F C2 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPUNORDSS instruction

InstructionOpcodeCPUID
CMPSS xmm1, xmm2/m32, imm8F3 0F C2 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPXCHG instruction

InstructionOpcodeCPUID
CMPXCHG r/m8, r80F B0 /r486+
CMPXCHG r/m16, r16o16 0F B1 /r486+
CMPXCHG r/m32, r32o32 0F B1 /r486+
CMPXCHG r/m64, r64o64 0F B1 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPXCHG16B instruction

InstructionOpcodeCPUID
CMPXCHG16B m128o64 0F C7 /1CMPXCHG16B
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPXCHG8B instruction

InstructionOpcodeCPUID
CMPXCHG8B m640F C7 /1CX8
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CMPZXADD instruction

InstructionOpcodeCPUID
CMPZXADD m32, r32, r32VEX.128.66.0F38.W0 E4 !(11):rrr:bbbCMPCCXADD
CMPZXADD m64, r64, r64VEX.128.66.0F38.W1 E4 !(11):rrr:bbbCMPCCXADD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

COMISD instruction

InstructionOpcodeCPUID
COMISD xmm1, xmm2/m6466 0F 2F /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

COMISS instruction

InstructionOpcodeCPUID
COMISS xmm1, xmm2/m32NP 0F 2F /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CPU_READ instruction

InstructionOpcodeCPUID
CPU_READ0F 3DCyrix MediaGX, GXm, GXLV, GX1
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CPU_WRITE instruction

InstructionOpcodeCPUID
CPU_WRITE0F 3CCyrix MediaGX, GXm, GXLV, GX1
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CPUID instruction

InstructionOpcodeCPUID
CPUID0F A2CPUID
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CQO instruction

InstructionOpcodeCPUID
CQOo64 99X64
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CRC32 instruction

InstructionOpcodeCPUID
CRC32 r32, r/m8F2 0F 38 F0 /rSSE4.2
CRC32 r64, r/m8F2 o64 0F 38 F0 /rSSE4.2
CRC32 r32, r/m16o16 F2 0F 38 F1 /rSSE4.2
CRC32 r32, r/m32o32 F2 0F 38 F1 /rSSE4.2
CRC32 r64, r/m64F2 o64 0F 38 F1 /rSSE4.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
Source

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

CVTDQ2PD instruction

InstructionOpcodeCPUID
CVTDQ2PD xmm1, xmm2/m64F3 0F E6 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTDQ2PS instruction

InstructionOpcodeCPUID
CVTDQ2PS xmm1, xmm2/m128NP 0F 5B /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTPD2DQ instruction

InstructionOpcodeCPUID
CVTPD2DQ xmm1, xmm2/m128F2 0F E6 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTPD2PI instruction

InstructionOpcodeCPUID
CVTPD2PI mm, xmm/m12866 0F 2D /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTPD2PS instruction

InstructionOpcodeCPUID
CVTPD2PS xmm1, xmm2/m12866 0F 5A /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTPI2PD instruction

InstructionOpcodeCPUID
CVTPI2PD xmm, mm/m6466 0F 2A /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTPI2PS instruction

InstructionOpcodeCPUID
CVTPI2PS xmm, mm/m64NP 0F 2A /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTPS2DQ instruction

InstructionOpcodeCPUID
CVTPS2DQ xmm1, xmm2/m12866 0F 5B /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTPS2PD instruction

InstructionOpcodeCPUID
CVTPS2PD xmm1, xmm2/m64NP 0F 5A /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTPS2PI instruction

InstructionOpcodeCPUID
CVTPS2PI mm, xmm/m64NP 0F 2D /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTSD2SI instruction

InstructionOpcodeCPUID
CVTSD2SI r32, xmm1/m64F2 0F 2D /rSSE2
CVTSD2SI r64, xmm1/m64F2 o64 0F 2D /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTSD2SS instruction

InstructionOpcodeCPUID
CVTSD2SS xmm1, xmm2/m64F2 0F 5A /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTSI2SD instruction

InstructionOpcodeCPUID
CVTSI2SD xmm1, r/m32F2 0F 2A /rSSE2
CVTSI2SD xmm1, r/m64F2 o64 0F 2A /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTSI2SS instruction

InstructionOpcodeCPUID
CVTSI2SS xmm1, r/m32F3 0F 2A /rSSE
CVTSI2SS xmm1, r/m64F3 o64 0F 2A /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTSS2SD instruction

InstructionOpcodeCPUID
CVTSS2SD xmm1, xmm2/m32F3 0F 5A /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTSS2SI instruction

InstructionOpcodeCPUID
CVTSS2SI r32, xmm1/m32F3 0F 2D /rSSE
CVTSS2SI r64, xmm1/m32F3 o64 0F 2D /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTTPD2DQ instruction

InstructionOpcodeCPUID
CVTTPD2DQ xmm1, xmm2/m12866 0F E6 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTTPD2PI instruction

InstructionOpcodeCPUID
CVTTPD2PI mm, xmm/m12866 0F 2C /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTTPS2DQ instruction

InstructionOpcodeCPUID
CVTTPS2DQ xmm1, xmm2/m128F3 0F 5B /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTTPS2PI instruction

InstructionOpcodeCPUID
CVTTPS2PI mm, xmm/m64NP 0F 2C /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTTSD2SI instruction

InstructionOpcodeCPUID
CVTTSD2SI r32, xmm1/m64F2 0F 2C /rSSE2
CVTTSD2SI r64, xmm1/m64F2 o64 0F 2C /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CVTTSS2SI instruction

InstructionOpcodeCPUID
CVTTSS2SI r32, xmm1/m32F3 0F 2C /rSSE
CVTTSS2SI r64, xmm1/m32F3 o64 0F 2C /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

CWD instruction

InstructionOpcodeCPUID
CWDo16 998086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

CWDE instruction

InstructionOpcodeCPUID
CWDEo32 98386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

DAA instruction

InstructionOpcodeCPUID
DAA278086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

DAS instruction

InstructionOpcodeCPUID
DAS2F8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

DEC instruction

InstructionOpcodeCPUID
DEC r16o16 48+rw8086+
DEC r32o32 48+rd386+
DEC r/m8FE /18086+
DEC r/m16o16 FF /18086+
DEC r/m32o32 FF /1386+
DEC r/m64o64 FF /1X64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

DIV instruction

InstructionOpcodeCPUID
DIV r/m8F6 /68086+
DIV r/m16o16 F7 /68086+
DIV r/m32o32 F7 /6386+
DIV r/m64o64 F7 /6X64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

DIVPD instruction

InstructionOpcodeCPUID
DIVPD xmm1, xmm2/m12866 0F 5E /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

DIVPS instruction

InstructionOpcodeCPUID
DIVPS xmm1, xmm2/m128NP 0F 5E /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

DIVSD instruction

InstructionOpcodeCPUID
DIVSD xmm1, xmm2/m64F2 0F 5E /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

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

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

DIVSS instruction

InstructionOpcodeCPUID
DIVSS xmm1, xmm2/m32F3 0F 5E /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

DMINT instruction

InstructionOpcodeCPUID
DMINT0F 39AMD Geode GX/LX
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

DPPD instruction

InstructionOpcodeCPUID
DPPD xmm1, xmm2/m128, imm866 0F 3A 41 /r ibSSE4.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
Source

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

DPPS instruction

InstructionOpcodeCPUID
DPPS xmm1, xmm2/m128, imm866 0F 3A 40 /r ibSSE4.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
Source

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

EMMS instruction

InstructionOpcodeCPUID
EMMSNP 0F 77MMX
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

ENCLS instruction

InstructionOpcodeCPUID
ENCLSNP 0F 01 CFSGX1
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

ENCLU instruction

InstructionOpcodeCPUID
ENCLUNP 0F 01 D7SGX1
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

ENCLV instruction

InstructionOpcodeCPUID
ENCLVNP 0F 01 C0OSS
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

ENCODEKEY128 instruction

InstructionOpcodeCPUID
ENCODEKEY128 r32, r32, <XMM0-2>, <XMM4-6>F3 0F 38 FA 11:rrr:bbbAESKLE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ENCODEKEY256 instruction

InstructionOpcodeCPUID
ENCODEKEY256 r32, r32, <XMM0-6>F3 0F 38 FB 11:rrr:bbbAESKLE
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ENDBR32 instruction

InstructionOpcodeCPUID
ENDBR32F3 0F 1E FBCET_IBT
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

ENDBR64 instruction

InstructionOpcodeCPUID
ENDBR64F3 0F 1E FACET_IBT
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

ENQCMD instruction

InstructionOpcodeCPUID
ENQCMD r16, m512a16 F2 0F 38 F8 !(11):rrr:bbbENQCMD
ENQCMD r32, m512a32 F2 0F 38 F8 !(11):rrr:bbbENQCMD
ENQCMD r64, m512a64 F2 0F 38 F8 !(11):rrr:bbbENQCMD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ENQCMDS instruction

InstructionOpcodeCPUID
ENQCMDS r16, m512a16 F3 0F 38 F8 !(11):rrr:bbbENQCMD
ENQCMDS r32, m512a32 F3 0F 38 F8 !(11):rrr:bbbENQCMD
ENQCMDS r64, m512a64 F3 0F 38 F8 !(11):rrr:bbbENQCMD
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ENTER instruction

InstructionOpcodeCPUID
ENTER imm16, imm8o16 C8 iw ib186+
ENTER imm16, imm8o32 C8 iw ib386+
ENTER imm16, imm8o64 C8 iw ibX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

ERETS instruction

InstructionOpcodeCPUID
ERETSF2 0F 01 CAFRED
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

ERETU instruction

InstructionOpcodeCPUID
ERETUF3 0F 01 CAFRED
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

EXTRACTPS instruction

InstructionOpcodeCPUID
EXTRACTPS r/m32, xmm1, imm866 0F 3A 17 /r ibSSE4.1
EXTRACTPS r64/m32, xmm1, imm866 o64 0F 3A 17 /r ibSSE4.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
Source

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

EXTRQ instruction

InstructionOpcodeCPUID
EXTRQ xmm1, xmm266 0F 79 /rSSE4A
§Errors

Fails if an operand is invalid (basic checks only)

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

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

InstructionOpcodeCPUID
EXTRQ xmm1, imm8, imm866 0F 78 /0 ib ibSSE4A
§Errors

Fails if an operand is invalid (basic checks only)

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

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

F2XM1 instruction

InstructionOpcodeCPUID
F2XM1D9 F08087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FABS instruction

InstructionOpcodeCPUID
FABSD9 E18087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FADD instruction

InstructionOpcodeCPUID
FADD m32fpD8 /08087+
FADD m64fpDC /08087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FADD instruction

InstructionOpcodeCPUID
FADD ST(0), ST(i)D8 C0+i8087+
FADD ST(i), ST(0)DC C0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FADDP instruction

InstructionOpcodeCPUID
FADDP ST(i), ST(0)DE C0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FBLD instruction

InstructionOpcodeCPUID
FBLD m80bcdDF /48087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FBSTP instruction

InstructionOpcodeCPUID
FBSTP m80bcdDF /68087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FCHS instruction

InstructionOpcodeCPUID
FCHSD9 E08087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FCLEX instruction

InstructionOpcodeCPUID
FCLEX9B DB E28087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FCMOVB instruction

InstructionOpcodeCPUID
FCMOVB ST(0), ST(i)DA C0+i8087+ 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
Source

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

FCMOVBE instruction

InstructionOpcodeCPUID
FCMOVBE ST(0), ST(i)DA D0+i8087+ 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
Source

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

FCMOVE instruction

InstructionOpcodeCPUID
FCMOVE ST(0), ST(i)DA C8+i8087+ 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
Source

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

FCMOVNB instruction

InstructionOpcodeCPUID
FCMOVNB ST(0), ST(i)DB C0+i8087+ 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
Source

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

FCMOVNBE instruction

InstructionOpcodeCPUID
FCMOVNBE ST(0), ST(i)DB D0+i8087+ 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
Source

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

FCMOVNE instruction

InstructionOpcodeCPUID
FCMOVNE ST(0), ST(i)DB C8+i8087+ 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
Source

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

FCMOVNU instruction

InstructionOpcodeCPUID
FCMOVNU ST(0), ST(i)DB D8+i8087+ 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
Source

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

FCMOVU instruction

InstructionOpcodeCPUID
FCMOVU ST(0), ST(i)DA D8+i8087+ 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
Source

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

FCOM instruction

InstructionOpcodeCPUID
FCOM m32fpD8 /28087+
FCOM m64fpDC /28087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FCOM instruction

InstructionOpcodeCPUID
FCOM ST(i)D8 D0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FCOMI instruction

InstructionOpcodeCPUID
FCOMI ST, ST(i)DB F0+i8087+ 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
Source

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

FCOMIP instruction

InstructionOpcodeCPUID
FCOMIP ST, ST(i)DF F0+i8087+ 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
Source

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

FCOMP instruction

InstructionOpcodeCPUID
FCOMP m32fpD8 /38087+
FCOMP m64fpDC /38087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FCOMP instruction

InstructionOpcodeCPUID
FCOMP ST(i)D8 D8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FCOMPP instruction

InstructionOpcodeCPUID
FCOMPPDE D98087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FCOS instruction

InstructionOpcodeCPUID
FCOSD9 FF387+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FDECSTP instruction

InstructionOpcodeCPUID
FDECSTPD9 F68087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FDISI instruction

InstructionOpcodeCPUID
FDISI9B DB E18087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FDIV instruction

InstructionOpcodeCPUID
FDIV m32fpD8 /68087+
FDIV m64fpDC /68087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FDIV instruction

InstructionOpcodeCPUID
FDIV ST(0), ST(i)D8 F0+i8087+
FDIV ST(i), ST(0)DC F8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FDIVP instruction

InstructionOpcodeCPUID
FDIVP ST(i), ST(0)DE F8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FDIVR instruction

InstructionOpcodeCPUID
FDIVR m32fpD8 /78087+
FDIVR m64fpDC /78087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FDIVR instruction

InstructionOpcodeCPUID
FDIVR ST(0), ST(i)D8 F8+i8087+
FDIVR ST(i), ST(0)DC F0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FDIVRP instruction

InstructionOpcodeCPUID
FDIVRP ST(i), ST(0)DE F0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FEMMS instruction

InstructionOpcodeCPUID
FEMMS0F 0E3DNOW
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FENI instruction

InstructionOpcodeCPUID
FENI9B DB E08087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FFREE instruction

InstructionOpcodeCPUID
FFREE ST(i)DD C0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FFREEP instruction

InstructionOpcodeCPUID
FFREEP ST(i)DF C0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FIADD instruction

InstructionOpcodeCPUID
FIADD m32intDA /08087+
FIADD m16intDE /08087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FICOM instruction

InstructionOpcodeCPUID
FICOM m32intDA /28087+
FICOM m16intDE /28087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FICOMP instruction

InstructionOpcodeCPUID
FICOMP m32intDA /38087+
FICOMP m16intDE /38087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FIDIV instruction

InstructionOpcodeCPUID
FIDIV m32intDA /68087+
FIDIV m16intDE /68087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FIDIVR instruction

InstructionOpcodeCPUID
FIDIVR m32intDA /78087+
FIDIVR m16intDE /78087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FILD instruction

InstructionOpcodeCPUID
FILD m32intDB /08087+
FILD m16intDF /08087+
FILD m64intDF /58087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FIMUL instruction

InstructionOpcodeCPUID
FIMUL m32intDA /18087+
FIMUL m16intDE /18087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FINCSTP instruction

InstructionOpcodeCPUID
FINCSTPD9 F78087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FINIT instruction

InstructionOpcodeCPUID
FINIT9B DB E38087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FIST instruction

InstructionOpcodeCPUID
FIST m32intDB /28087+
FIST m16intDF /28087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FISTP instruction

InstructionOpcodeCPUID
FISTP m32intDB /38087+
FISTP m16intDF /38087+
FISTP m64intDF /78087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FISTTP instruction

InstructionOpcodeCPUID
FISTTP m32intDB /18087+ SSE3
FISTTP m64intDD /18087+ SSE3
FISTTP m16intDF /18087+ 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)
Source

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

FISUB instruction

InstructionOpcodeCPUID
FISUB m32intDA /48087+
FISUB m16intDE /48087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FISUBR instruction

InstructionOpcodeCPUID
FISUBR m32intDA /58087+
FISUBR m16intDE /58087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FLD instruction

InstructionOpcodeCPUID
FLD m32fpD9 /08087+
FLD m80fpDB /58087+
FLD m64fpDD /08087+
FLD ST(i)D9 C0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FLD1 instruction

InstructionOpcodeCPUID
FLD1D9 E88087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FLDCW instruction

InstructionOpcodeCPUID
FLDCW m2byteD9 /58087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FLDENV instruction

InstructionOpcodeCPUID
FLDENV m14byteo16 D9 /48087+
FLDENV m28byteo32 D9 /4387+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FLDL2E instruction

InstructionOpcodeCPUID
FLDL2ED9 EA8087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FLDL2T instruction

InstructionOpcodeCPUID
FLDL2TD9 E98087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FLDLG2 instruction

InstructionOpcodeCPUID
FLDLG2D9 EC8087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FLDLN2 instruction

InstructionOpcodeCPUID
FLDLN2D9 ED8087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FLDPI instruction

InstructionOpcodeCPUID
FLDPID9 EB8087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FLDZ instruction

InstructionOpcodeCPUID
FLDZD9 EE8087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FMUL instruction

InstructionOpcodeCPUID
FMUL m32fpD8 /18087+
FMUL m64fpDC /18087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FMUL instruction

InstructionOpcodeCPUID
FMUL ST(0), ST(i)D8 C8+i8087+
FMUL ST(i), ST(0)DC C8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FMULP instruction

InstructionOpcodeCPUID
FMULP ST(i), ST(0)DE C8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FNCLEX instruction

InstructionOpcodeCPUID
FNCLEXDB E28087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FNDISI instruction

InstructionOpcodeCPUID
FNDISIDB E18087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FNENI instruction

InstructionOpcodeCPUID
FNENIDB E08087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FNINIT instruction

InstructionOpcodeCPUID
FNINITDB E38087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FNOP instruction

InstructionOpcodeCPUID
FNOPD9 D08087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FNSAVE instruction

InstructionOpcodeCPUID
FNSAVE m94byteo16 DD /68087+
FNSAVE m108byteo32 DD /6387+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FNSETPM instruction

InstructionOpcodeCPUID
FNSETPMDB E4287+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FNSTCW instruction

InstructionOpcodeCPUID
FNSTCW m2byteD9 /78087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FNSTDW instruction

InstructionOpcodeCPUID
FNSTDW AXDF E1387 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)
Source

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

FNSTENV instruction

InstructionOpcodeCPUID
FNSTENV m14byteo16 D9 /68087+
FNSTENV m28byteo32 D9 /6387+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FNSTSG instruction

InstructionOpcodeCPUID
FNSTSG AXDF E2387 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)
Source

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

FNSTSW instruction

InstructionOpcodeCPUID
FNSTSW m2byteDD /78087+
FNSTSW AXDF E0287+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FPATAN instruction

InstructionOpcodeCPUID
FPATAND9 F38087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FPREM instruction

InstructionOpcodeCPUID
FPREMD9 F88087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FPREM1 instruction

InstructionOpcodeCPUID
FPREM1D9 F5387+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FPTAN instruction

InstructionOpcodeCPUID
FPTAND9 F28087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FRNDINT instruction

InstructionOpcodeCPUID
FRNDINTD9 FC8087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FRSTOR instruction

InstructionOpcodeCPUID
FRSTOR m94byteo16 DD /48087+
FRSTOR m108byteo32 DD /4387+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FRSTPM instruction

InstructionOpcodeCPUID
FRSTPMDB E5287 XL
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FSAVE instruction

InstructionOpcodeCPUID
FSAVE m94byte9B o16 DD /68087+
FSAVE m108byte9B o32 DD /6387+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSCALE instruction

InstructionOpcodeCPUID
FSCALED9 FD8087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FSETPM instruction

InstructionOpcodeCPUID
FSETPM9B DB E4287+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FSIN instruction

InstructionOpcodeCPUID
FSIND9 FE387+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FSINCOS instruction

InstructionOpcodeCPUID
FSINCOSD9 FB387+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FSQRT instruction

InstructionOpcodeCPUID
FSQRTD9 FA8087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FST instruction

InstructionOpcodeCPUID
FST m32fpD9 /28087+
FST m64fpDD /28087+
FST ST(i)DD D0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSTCW instruction

InstructionOpcodeCPUID
FSTCW m2byte9B D9 /78087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSTDW instruction

InstructionOpcodeCPUID
FSTDW AX9B DF E1387 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)
Source

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

FSTENV instruction

InstructionOpcodeCPUID
FSTENV m14byte9B o16 D9 /68087+
FSTENV m28byte9B o32 D9 /6387+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSTP instruction

InstructionOpcodeCPUID
FSTP m32fpD9 /38087+
FSTP m80fpDB /78087+
FSTP m64fpDD /38087+
FSTP ST(i)DD D8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSTPNCE instruction

InstructionOpcodeCPUID
FSTPNCE ST(i)D9 D8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSTSG instruction

InstructionOpcodeCPUID
FSTSG AX9B DF E2387 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)
Source

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

FSTSW instruction

InstructionOpcodeCPUID
FSTSW m2byte9B DD /78087+
FSTSW AX9B DF E0287+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSUB instruction

InstructionOpcodeCPUID
FSUB m32fpD8 /48087+
FSUB m64fpDC /48087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSUB instruction

InstructionOpcodeCPUID
FSUB ST(0), ST(i)D8 E0+i8087+
FSUB ST(i), ST(0)DC E8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSUBP instruction

InstructionOpcodeCPUID
FSUBP ST(i), ST(0)DE E8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSUBR instruction

InstructionOpcodeCPUID
FSUBR m32fpD8 /58087+
FSUBR m64fpDC /58087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSUBR instruction

InstructionOpcodeCPUID
FSUBR ST(0), ST(i)D8 E8+i8087+
FSUBR ST(i), ST(0)DC E0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FSUBRP instruction

InstructionOpcodeCPUID
FSUBRP ST(i), ST(0)DE E0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FTST instruction

InstructionOpcodeCPUID
FTSTD9 E48087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FUCOM instruction

InstructionOpcodeCPUID
FUCOM ST(i)DD E0+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FUCOMI instruction

InstructionOpcodeCPUID
FUCOMI ST, ST(i)DB E8+i8087+ 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
Source

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

FUCOMIP instruction

InstructionOpcodeCPUID
FUCOMIP ST, ST(i)DF E8+i8087+ 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
Source

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

FUCOMP instruction

InstructionOpcodeCPUID
FUCOMP ST(i)DD E8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FUCOMPP instruction

InstructionOpcodeCPUID
FUCOMPPDA E9387+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FXAM instruction

InstructionOpcodeCPUID
FXAMD9 E58087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FXCH instruction

InstructionOpcodeCPUID
FXCH ST(i)D9 C8+i8087+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FXRSTOR instruction

InstructionOpcodeCPUID
FXRSTOR m512byteNP 0F AE /1FXSR
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FXRSTOR64 instruction

InstructionOpcodeCPUID
FXRSTOR64 m512byteNP o64 0F AE /1FXSR
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FXSAVE instruction

InstructionOpcodeCPUID
FXSAVE m512byteNP 0F AE /0FXSR
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FXSAVE64 instruction

InstructionOpcodeCPUID
FXSAVE64 m512byteNP o64 0F AE /0FXSR
§Errors

Fails if an operand is invalid (basic checks only)

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

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

FXTRACT instruction

InstructionOpcodeCPUID
FXTRACTD9 F48087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FYL2X instruction

InstructionOpcodeCPUID
FYL2XD9 F18087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

FYL2XP1 instruction

InstructionOpcodeCPUID
FYL2XP1D9 F98087+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

GETSEC instruction

InstructionOpcodeCPUID
GETSECNP 0F 37SMX
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

GETSECQ instruction

InstructionOpcodeCPUID
GETSECQNP o64 0F 37SMX
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

GF2P8AFFINEINVQB instruction

InstructionOpcodeCPUID
GF2P8AFFINEINVQB xmm1, xmm2/m128, imm866 0F 3A CF /r ibGFNI
§Errors

Fails if an operand is invalid (basic checks only)

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

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

GF2P8AFFINEQB instruction

InstructionOpcodeCPUID
GF2P8AFFINEQB xmm1, xmm2/m128, imm866 0F 3A CE /r ibGFNI
§Errors

Fails if an operand is invalid (basic checks only)

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

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

GF2P8MULB instruction

InstructionOpcodeCPUID
GF2P8MULB xmm1, xmm2/m12866 0F 38 CF /rGFNI
§Errors

Fails if an operand is invalid (basic checks only)

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

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

HADDPD instruction

InstructionOpcodeCPUID
HADDPD xmm1, xmm2/m12866 0F 7C /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

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

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

HADDPS instruction

InstructionOpcodeCPUID
HADDPS xmm1, xmm2/m128F2 0F 7C /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

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

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

HLT instruction

InstructionOpcodeCPUID
HLTF48086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

HRESET instruction

InstructionOpcodeCPUID
HRESET imm8, <EAX>F3 0F 3A F0 C0 ibHRESET
§Errors

Fails if an operand is invalid (basic checks only)

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

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

HSUBPD instruction

InstructionOpcodeCPUID
HSUBPD xmm1, xmm2/m12866 0F 7D /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

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

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

HSUBPS instruction

InstructionOpcodeCPUID
HSUBPS xmm1, xmm2/m128F2 0F 7D /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

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

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

IBTS instruction

InstructionOpcodeCPUID
IBTS r/m16, r16o16 0F A7 /r386 A0
IBTS r/m32, r32o32 0F A7 /r386 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
Source

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

IDIV instruction

InstructionOpcodeCPUID
IDIV r/m8F6 /78086+
IDIV r/m16o16 F7 /78086+
IDIV r/m32o32 F7 /7386+
IDIV r/m64o64 F7 /7X64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

IMUL instruction

InstructionOpcodeCPUID
IMUL r/m8F6 /58086+
IMUL r/m16o16 F7 /58086+
IMUL r/m32o32 F7 /5386+
IMUL r/m64o64 F7 /5X64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

IMUL instruction

InstructionOpcodeCPUID
IMUL r16, r/m16o16 0F AF /r386+
IMUL r32, r/m32o32 0F AF /r386+
IMUL r64, r/m64o64 0F AF /rX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

InstructionOpcodeCPUID
IMUL r16, r/m16, imm16o16 69 /r iw186+
IMUL r32, r/m32, imm32o32 69 /r id386+
IMUL r64, r/m64, imm32o64 69 /r idX64
IMUL r16, r/m16, imm8o16 6B /r ib186+
IMUL r32, r/m32, imm8o32 6B /r ib386+
IMUL r64, r/m64, imm8o64 6B /r ibX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

IN instruction

InstructionOpcodeCPUID
IN AL, imm8E4 ib8086+
IN AX, imm8o16 E5 ib8086+
IN EAX, imm8o32 E5 ib386+
IN AL, DXEC8086+
IN AX, DXo16 ED8086+
IN EAX, DXo32 ED386+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

INC instruction

InstructionOpcodeCPUID
INC r16o16 40+rw8086+
INC r32o32 40+rd386+
INC r/m8FE /08086+
INC r/m16o16 FF /08086+
INC r/m32o32 FF /0386+
INC r/m64o64 FF /0X64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

INCSSPD instruction

InstructionOpcodeCPUID
INCSSPD r32F3 0F AE /5CET_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)
Source

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

INCSSPQ instruction

InstructionOpcodeCPUID
INCSSPQ r64F3 o64 0F AE /5CET_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)
Source

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

INSB instruction

InstructionOpcodeCPUID
INSB6C186+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

INSD instruction

InstructionOpcodeCPUID
INSDo32 6D386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

INSERTPS instruction

InstructionOpcodeCPUID
INSERTPS xmm1, xmm2/m32, imm866 0F 3A 21 /r ibSSE4.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
Source

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

INSERTQ instruction

InstructionOpcodeCPUID
INSERTQ xmm1, xmm2F2 0F 79 /rSSE4A
§Errors

Fails if an operand is invalid (basic checks only)

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

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

InstructionOpcodeCPUID
INSERTQ xmm1, xmm2, imm8, imm8F2 0F 78 /r ib ibSSE4A
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

INSW instruction

InstructionOpcodeCPUID
INSWo16 6D186+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

INT instruction

InstructionOpcodeCPUID
INT imm8CD ib8086+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

INT1 instruction

InstructionOpcodeCPUID
INT1F1386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

INT3 instruction

InstructionOpcodeCPUID
INT3CC8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

INTO instruction

InstructionOpcodeCPUID
INTOCE8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

INVD instruction

InstructionOpcodeCPUID
INVD0F 08486+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

INVEPT instruction

InstructionOpcodeCPUID
INVEPT r32, m12866 0F 38 80 /rVMX IA32_VMX_EPT_VPID_CAP[bit 20]
INVEPT r64, m12866 0F 38 80 /rVMX 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
Source

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

INVLPG instruction

InstructionOpcodeCPUID
INVLPG m0F 01 /7486+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

INVLPGA instruction

InstructionOpcodeCPUID
INVLPGAa16 0F 01 DFSVM
INVLPGAa32 0F 01 DFSVM
INVLPGAa64 0F 01 DFSVM
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

INVLPGB instruction

InstructionOpcodeCPUID
INVLPGBa16 NP 0F 01 FEINVLPGB
INVLPGBa32 NP 0F 01 FEINVLPGB
INVLPGBa64 NP 0F 01 FEINVLPGB
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

INVPCID instruction

InstructionOpcodeCPUID
INVPCID r32, m12866 0F 38 82 /rINVPCID
INVPCID r64, m12866 0F 38 82 /rINVPCID
§Errors

Fails if an operand is invalid (basic checks only)

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

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

INVVPID instruction

InstructionOpcodeCPUID
INVVPID r32, m12866 0F 38 81 /rVMX IA32_VMX_EPT_VPID_CAP[bit 32]
INVVPID r64, m12866 0F 38 81 /rVMX 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
Source

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

IRET instruction

InstructionOpcodeCPUID
IRETo16 CF8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

IRETD instruction

InstructionOpcodeCPUID
IRETDo32 CF386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

IRETQ instruction

InstructionOpcodeCPUID
IRETQo64 CFX64
§Errors

Fails if an operand is invalid (basic checks only)

Source

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

JA instruction

InstructionOpcodeCPUID
JA rel8o16 77 cb8086+
JA rel8o32 77 cb386+
JA rel8o64 77 cbX64
JA rel16o16 0F 87 cw386+
JA rel32o32 0F 87 cd386+
JA rel32o64 0F 87 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JAE instruction

InstructionOpcodeCPUID
JAE rel8o16 73 cb8086+
JAE rel8o32 73 cb386+
JAE rel8o64 73 cbX64
JAE rel16o16 0F 83 cw386+
JAE rel32o32 0F 83 cd386+
JAE rel32o64 0F 83 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JB instruction

InstructionOpcodeCPUID
JB rel8o16 72 cb8086+
JB rel8o32 72 cb386+
JB rel8o64 72 cbX64
JB rel16o16 0F 82 cw386+
JB rel32o32 0F 82 cd386+
JB rel32o64 0F 82 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JBE instruction

InstructionOpcodeCPUID
JBE rel8o16 76 cb8086+
JBE rel8o32 76 cb386+
JBE rel8o64 76 cbX64
JBE rel16o16 0F 86 cw386+
JBE rel32o32 0F 86 cd386+
JBE rel32o64 0F 86 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JC instruction

InstructionOpcodeCPUID
JB rel8o16 72 cb8086+
JB rel8o32 72 cb386+
JB rel8o64 72 cbX64
JB rel16o16 0F 82 cw386+
JB rel32o32 0F 82 cd386+
JB rel32o64 0F 82 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JCXZ instruction

InstructionOpcodeCPUID
JCXZ rel8a16 o16 E3 cb8086+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JE instruction

InstructionOpcodeCPUID
JE rel8o16 74 cb8086+
JE rel8o32 74 cb386+
JE rel8o64 74 cbX64
JE rel16o16 0F 84 cw386+
JE rel32o32 0F 84 cd386+
JE rel32o64 0F 84 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JECXZ instruction

InstructionOpcodeCPUID
JECXZ rel8a32 o32 E3 cb386+
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JG instruction

InstructionOpcodeCPUID
JG rel8o16 7F cb8086+
JG rel8o32 7F cb386+
JG rel8o64 7F cbX64
JG rel16o16 0F 8F cw386+
JG rel32o32 0F 8F cd386+
JG rel32o64 0F 8F cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JGE instruction

InstructionOpcodeCPUID
JGE rel8o16 7D cb8086+
JGE rel8o32 7D cb386+
JGE rel8o64 7D cbX64
JGE rel16o16 0F 8D cw386+
JGE rel32o32 0F 8D cd386+
JGE rel32o64 0F 8D cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JL instruction

InstructionOpcodeCPUID
JL rel8o16 7C cb8086+
JL rel8o32 7C cb386+
JL rel8o64 7C cbX64
JL rel16o16 0F 8C cw386+
JL rel32o32 0F 8C cd386+
JL rel32o64 0F 8C cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JLE instruction

InstructionOpcodeCPUID
JLE rel8o16 7E cb8086+
JLE rel8o32 7E cb386+
JLE rel8o64 7E cbX64
JLE rel16o16 0F 8E cw386+
JLE rel32o32 0F 8E cd386+
JLE rel32o64 0F 8E cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JMP instruction

InstructionOpcodeCPUID
JMP rel16o16 E9 cw8086+
JMP rel32o32 E9 cd386+
JMP rel32o64 E9 cdX64
JMP rel8o16 EB cb8086+
JMP rel8o32 EB cb386+
JMP rel8o64 EB cbX64
JMP r/m16o16 FF /48086+
JMP r/m32o32 FF /4386+
JMP r/m64o64 FF /4X64
JMP m16:16o16 FF /58086+
JMP m16:32o32 FF /5386+
JMP m16:64o64 FF /5X64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JMPE instruction

InstructionOpcodeCPUID
JMPE r/m16o16 0F 00 /6IA-64
JMPE r/m32o32 0F 00 /6IA-64
JMPE disp16o16 0F B8 cwIA-64
JMPE disp32o32 0F B8 cdIA-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)
Source

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

JNA instruction

InstructionOpcodeCPUID
JBE rel8o16 76 cb8086+
JBE rel8o32 76 cb386+
JBE rel8o64 76 cbX64
JBE rel16o16 0F 86 cw386+
JBE rel32o32 0F 86 cd386+
JBE rel32o64 0F 86 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNAE instruction

InstructionOpcodeCPUID
JB rel8o16 72 cb8086+
JB rel8o32 72 cb386+
JB rel8o64 72 cbX64
JB rel16o16 0F 82 cw386+
JB rel32o32 0F 82 cd386+
JB rel32o64 0F 82 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNB instruction

InstructionOpcodeCPUID
JAE rel8o16 73 cb8086+
JAE rel8o32 73 cb386+
JAE rel8o64 73 cbX64
JAE rel16o16 0F 83 cw386+
JAE rel32o32 0F 83 cd386+
JAE rel32o64 0F 83 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNBE instruction

InstructionOpcodeCPUID
JA rel8o16 77 cb8086+
JA rel8o32 77 cb386+
JA rel8o64 77 cbX64
JA rel16o16 0F 87 cw386+
JA rel32o32 0F 87 cd386+
JA rel32o64 0F 87 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNC instruction

InstructionOpcodeCPUID
JAE rel8o16 73 cb8086+
JAE rel8o32 73 cb386+
JAE rel8o64 73 cbX64
JAE rel16o16 0F 83 cw386+
JAE rel32o32 0F 83 cd386+
JAE rel32o64 0F 83 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNE instruction

InstructionOpcodeCPUID
JNE rel8o16 75 cb8086+
JNE rel8o32 75 cb386+
JNE rel8o64 75 cbX64
JNE rel16o16 0F 85 cw386+
JNE rel32o32 0F 85 cd386+
JNE rel32o64 0F 85 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNG instruction

InstructionOpcodeCPUID
JLE rel8o16 7E cb8086+
JLE rel8o32 7E cb386+
JLE rel8o64 7E cbX64
JLE rel16o16 0F 8E cw386+
JLE rel32o32 0F 8E cd386+
JLE rel32o64 0F 8E cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNGE instruction

InstructionOpcodeCPUID
JL rel8o16 7C cb8086+
JL rel8o32 7C cb386+
JL rel8o64 7C cbX64
JL rel16o16 0F 8C cw386+
JL rel32o32 0F 8C cd386+
JL rel32o64 0F 8C cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNL instruction

InstructionOpcodeCPUID
JGE rel8o16 7D cb8086+
JGE rel8o32 7D cb386+
JGE rel8o64 7D cbX64
JGE rel16o16 0F 8D cw386+
JGE rel32o32 0F 8D cd386+
JGE rel32o64 0F 8D cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNLE instruction

InstructionOpcodeCPUID
JG rel8o16 7F cb8086+
JG rel8o32 7F cb386+
JG rel8o64 7F cbX64
JG rel16o16 0F 8F cw386+
JG rel32o32 0F 8F cd386+
JG rel32o64 0F 8F cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNO instruction

InstructionOpcodeCPUID
JNO rel8o16 71 cb8086+
JNO rel8o32 71 cb386+
JNO rel8o64 71 cbX64
JNO rel16o16 0F 81 cw386+
JNO rel32o32 0F 81 cd386+
JNO rel32o64 0F 81 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNP instruction

InstructionOpcodeCPUID
JNP rel8o16 7B cb8086+
JNP rel8o32 7B cb386+
JNP rel8o64 7B cbX64
JNP rel16o16 0F 8B cw386+
JNP rel32o32 0F 8B cd386+
JNP rel32o64 0F 8B cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNS instruction

InstructionOpcodeCPUID
JNS rel8o16 79 cb8086+
JNS rel8o32 79 cb386+
JNS rel8o64 79 cbX64
JNS rel16o16 0F 89 cw386+
JNS rel32o32 0F 89 cd386+
JNS rel32o64 0F 89 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JNZ instruction

InstructionOpcodeCPUID
JNE rel8o16 75 cb8086+
JNE rel8o32 75 cb386+
JNE rel8o64 75 cbX64
JNE rel16o16 0F 85 cw386+
JNE rel32o32 0F 85 cd386+
JNE rel32o64 0F 85 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JO instruction

InstructionOpcodeCPUID
JO rel8o16 70 cb8086+
JO rel8o32 70 cb386+
JO rel8o64 70 cbX64
JO rel16o16 0F 80 cw386+
JO rel32o32 0F 80 cd386+
JO rel32o64 0F 80 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JP instruction

InstructionOpcodeCPUID
JP rel8o16 7A cb8086+
JP rel8o32 7A cb386+
JP rel8o64 7A cbX64
JP rel16o16 0F 8A cw386+
JP rel32o32 0F 8A cd386+
JP rel32o64 0F 8A cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JPE instruction

InstructionOpcodeCPUID
JP rel8o16 7A cb8086+
JP rel8o32 7A cb386+
JP rel8o64 7A cbX64
JP rel16o16 0F 8A cw386+
JP rel32o32 0F 8A cd386+
JP rel32o64 0F 8A cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JPO instruction

InstructionOpcodeCPUID
JNP rel8o16 7B cb8086+
JNP rel8o32 7B cb386+
JNP rel8o64 7B cbX64
JNP rel16o16 0F 8B cw386+
JNP rel32o32 0F 8B cd386+
JNP rel32o64 0F 8B cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JRCXZ instruction

InstructionOpcodeCPUID
JRCXZ rel8a64 o64 E3 cbX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JS instruction

InstructionOpcodeCPUID
JS rel8o16 78 cb8086+
JS rel8o32 78 cb386+
JS rel8o64 78 cbX64
JS rel16o16 0F 88 cw386+
JS rel32o32 0F 88 cd386+
JS rel32o64 0F 88 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

JZ instruction

InstructionOpcodeCPUID
JE rel8o16 74 cb8086+
JE rel8o32 74 cb386+
JE rel8o64 74 cbX64
JE rel16o16 0F 84 cw386+
JE rel32o32 0F 84 cd386+
JE rel32o64 0F 84 cdX64
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KADDB instruction

InstructionOpcodeCPUID
KADDB k1, k2, k3VEX.L1.66.0F.W0 4A /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KADDD instruction

InstructionOpcodeCPUID
KADDD k1, k2, k3VEX.L1.66.0F.W1 4A /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KADDQ instruction

InstructionOpcodeCPUID
KADDQ k1, k2, k3VEX.L1.0F.W1 4A /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KADDW instruction

InstructionOpcodeCPUID
KADDW k1, k2, k3VEX.L1.0F.W0 4A /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KANDB instruction

InstructionOpcodeCPUID
KANDB k1, k2, k3VEX.L1.66.0F.W0 41 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KANDD instruction

InstructionOpcodeCPUID
KANDD k1, k2, k3VEX.L1.66.0F.W1 41 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KANDNB instruction

InstructionOpcodeCPUID
KANDNB k1, k2, k3VEX.L1.66.0F.W0 42 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KANDND instruction

InstructionOpcodeCPUID
KANDND k1, k2, k3VEX.L1.66.0F.W1 42 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KANDNQ instruction

InstructionOpcodeCPUID
KANDNQ k1, k2, k3VEX.L1.0F.W1 42 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KANDNW instruction

InstructionOpcodeCPUID
KANDNW k1, k2, k3VEX.L1.0F.W0 42 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KANDQ instruction

InstructionOpcodeCPUID
KANDQ k1, k2, k3VEX.L1.0F.W1 41 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

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

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

KANDW instruction

InstructionOpcodeCPUID
KANDW k1, k2, k3VEX.L1.0F.W0 41 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kmovb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKmovb<T, U>,

KMOVB instruction

InstructionOpcodeCPUID
KMOVB k1, k2/m8VEX.L0.66.0F.W0 90 /rAVX512DQ
KMOVB m8, k1VEX.L0.66.0F.W0 91 /rAVX512DQ
KMOVB k1, r32VEX.L0.66.0F.W0 92 /rAVX512DQ
KMOVB r32, k1VEX.L0.66.0F.W0 93 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn kmovd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKmovd<T, U>,

KMOVD instruction

InstructionOpcodeCPUID
KMOVD k1, k2/m32VEX.L0.66.0F.W1 90 /rAVX512BW
KMOVD m32, k1VEX.L0.66.0F.W1 91 /rAVX512BW
KMOVD k1, r32VEX.L0.F2.0F.W0 92 /rAVX512BW
KMOVD r32, k1VEX.L0.F2.0F.W0 93 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn kmovq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKmovq<T, U>,

KMOVQ instruction

InstructionOpcodeCPUID
KMOVQ k1, k2/m64VEX.L0.0F.W1 90 /rAVX512BW
KMOVQ m64, k1VEX.L0.0F.W1 91 /rAVX512BW
KMOVQ k1, r64VEX.L0.F2.0F.W1 92 /rAVX512BW
KMOVQ r64, k1VEX.L0.F2.0F.W1 93 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn kmovw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKmovw<T, U>,

KMOVW instruction

InstructionOpcodeCPUID
KMOVW k1, k2/m16VEX.L0.0F.W0 90 /rAVX512F
KMOVW m16, k1VEX.L0.0F.W0 91 /rAVX512F
KMOVW k1, r32VEX.L0.0F.W0 92 /rAVX512F
KMOVW r32, k1VEX.L0.0F.W0 93 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn knotb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKnotb<T, U>,

KNOTB instruction

InstructionOpcodeCPUID
KNOTB k1, k2VEX.L0.66.0F.W0 44 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn knotd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKnotd<T, U>,

KNOTD instruction

InstructionOpcodeCPUID
KNOTD k1, k2VEX.L0.66.0F.W1 44 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn knotq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKnotq<T, U>,

KNOTQ instruction

InstructionOpcodeCPUID
KNOTQ k1, k2VEX.L0.0F.W1 44 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn knotw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKnotw<T, U>,

KNOTW instruction

InstructionOpcodeCPUID
KNOTW k1, k2VEX.L0.0F.W0 44 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn korb<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmKorb<T, U, V>,

KORB instruction

InstructionOpcodeCPUID
KORB k1, k2, k3VEX.L1.66.0F.W0 45 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kord<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmKord<T, U, V>,

KORD instruction

InstructionOpcodeCPUID
KORD k1, k2, k3VEX.L1.66.0F.W1 45 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn korq<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmKorq<T, U, V>,

KORQ instruction

InstructionOpcodeCPUID
KORQ k1, k2, k3VEX.L1.0F.W1 45 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kortestb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKortestb<T, U>,

KORTESTB instruction

InstructionOpcodeCPUID
KORTESTB k1, k2VEX.L0.66.0F.W0 98 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn kortestd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKortestd<T, U>,

KORTESTD instruction

InstructionOpcodeCPUID
KORTESTD k1, k2VEX.L0.66.0F.W1 98 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn kortestq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKortestq<T, U>,

KORTESTQ instruction

InstructionOpcodeCPUID
KORTESTQ k1, k2VEX.L0.0F.W1 98 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn kortestw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKortestw<T, U>,

KORTESTW instruction

InstructionOpcodeCPUID
KORTESTW k1, k2VEX.L0.0F.W0 98 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn korw<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmKorw<T, U, V>,

KORW instruction

InstructionOpcodeCPUID
KORW k1, k2, k3VEX.L1.0F.W0 45 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kshiftlb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKshiftlb<T, U, V>,

KSHIFTLB instruction

InstructionOpcodeCPUID
KSHIFTLB k1, k2, imm8VEX.L0.66.0F3A.W0 32 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kshiftld<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKshiftld<T, U, V>,

KSHIFTLD instruction

InstructionOpcodeCPUID
KSHIFTLD k1, k2, imm8VEX.L0.66.0F3A.W0 33 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kshiftlq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKshiftlq<T, U, V>,

KSHIFTLQ instruction

InstructionOpcodeCPUID
KSHIFTLQ k1, k2, imm8VEX.L0.66.0F3A.W1 33 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kshiftlw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKshiftlw<T, U, V>,

KSHIFTLW instruction

InstructionOpcodeCPUID
KSHIFTLW k1, k2, imm8VEX.L0.66.0F3A.W1 32 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kshiftrb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKshiftrb<T, U, V>,

KSHIFTRB instruction

InstructionOpcodeCPUID
KSHIFTRB k1, k2, imm8VEX.L0.66.0F3A.W0 30 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kshiftrd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKshiftrd<T, U, V>,

KSHIFTRD instruction

InstructionOpcodeCPUID
KSHIFTRD k1, k2, imm8VEX.L0.66.0F3A.W0 31 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kshiftrq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKshiftrq<T, U, V>,

KSHIFTRQ instruction

InstructionOpcodeCPUID
KSHIFTRQ k1, k2, imm8VEX.L0.66.0F3A.W1 31 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kshiftrw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKshiftrw<T, U, V>,

KSHIFTRW instruction

InstructionOpcodeCPUID
KSHIFTRW k1, k2, imm8VEX.L0.66.0F3A.W1 30 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn ktestb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKtestb<T, U>,

KTESTB instruction

InstructionOpcodeCPUID
KTESTB k1, k2VEX.L0.66.0F.W0 99 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ktestd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKtestd<T, U>,

KTESTD instruction

InstructionOpcodeCPUID
KTESTD k1, k2VEX.L0.66.0F.W1 99 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ktestq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKtestq<T, U>,

KTESTQ instruction

InstructionOpcodeCPUID
KTESTQ k1, k2VEX.L0.0F.W1 99 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ktestw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmKtestw<T, U>,

KTESTW instruction

InstructionOpcodeCPUID
KTESTW k1, k2VEX.L0.0F.W0 99 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn kunpckbw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKunpckbw<T, U, V>,

KUNPCKBW instruction

InstructionOpcodeCPUID
KUNPCKBW k1, k2, k3VEX.L1.66.0F.W0 4B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kunpckdq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKunpckdq<T, U, V>,

KUNPCKDQ instruction

InstructionOpcodeCPUID
KUNPCKDQ k1, k2, k3VEX.L1.0F.W1 4B /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kunpckwd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKunpckwd<T, U, V>,

KUNPCKWD instruction

InstructionOpcodeCPUID
KUNPCKWD k1, k2, k3VEX.L1.0F.W0 4B /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kxnorb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKxnorb<T, U, V>,

KXNORB instruction

InstructionOpcodeCPUID
KXNORB k1, k2, k3VEX.L1.66.0F.W0 46 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kxnord<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKxnord<T, U, V>,

KXNORD instruction

InstructionOpcodeCPUID
KXNORD k1, k2, k3VEX.L1.66.0F.W1 46 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kxnorq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKxnorq<T, U, V>,

KXNORQ instruction

InstructionOpcodeCPUID
KXNORQ k1, k2, k3VEX.L1.0F.W1 46 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kxnorw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKxnorw<T, U, V>,

KXNORW instruction

InstructionOpcodeCPUID
KXNORW k1, k2, k3VEX.L1.0F.W0 46 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kxorb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKxorb<T, U, V>,

KXORB instruction

InstructionOpcodeCPUID
KXORB k1, k2, k3VEX.L1.66.0F.W0 47 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kxord<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKxord<T, U, V>,

KXORD instruction

InstructionOpcodeCPUID
KXORD k1, k2, k3VEX.L1.66.0F.W1 47 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kxorq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKxorq<T, U, V>,

KXORQ instruction

InstructionOpcodeCPUID
KXORQ k1, k2, k3VEX.L1.0F.W1 47 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn kxorw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmKxorw<T, U, V>,

KXORW instruction

InstructionOpcodeCPUID
KXORW k1, k2, k3VEX.L1.0F.W0 47 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn lahf(&mut self) -> Result<(), IcedError>
where Self: CodeAsmLahf,

LAHF instruction

InstructionOpcodeCPUID
LAHF9F8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn lar<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLar<T, U>,

LAR instruction

InstructionOpcodeCPUID
LAR r16, r/m16o16 0F 02 /r286+
LAR r32, r32/m16o32 0F 02 /r386+
LAR r64, r64/m16o64 0F 02 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn lddqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLddqu<T, U>,

LDDQU instruction

InstructionOpcodeCPUID
LDDQU xmm1, m128F2 0F F0 /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ldmxcsr<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLdmxcsr<T>,

LDMXCSR instruction

InstructionOpcodeCPUID
LDMXCSR m32NP 0F AE /2SSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn lds<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLds<T, U>,

LDS instruction

InstructionOpcodeCPUID
LDS r16, m16:16o16 C5 /r8086+
LDS r32, m16:32o32 C5 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ldtilecfg<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLdtilecfg<T>,

LDTILECFG instruction

InstructionOpcodeCPUID
LDTILECFG m512VEX.128.0F38.W0 49 !(11):000:bbbAMX-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)
Source

pub fn lea<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLea<T, U>,

LEA instruction

InstructionOpcodeCPUID
LEA r16, mo16 8D /r8086+
LEA r32, mo32 8D /r386+
LEA r64, mo64 8D /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn leave(&mut self) -> Result<(), IcedError>
where Self: CodeAsmLeave,

LEAVE instruction

InstructionOpcodeCPUID
LEAVEo16 C9186+
LEAVEo32 C9386+
LEAVEo64 C9X64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn les<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLes<T, U>,

LES instruction

InstructionOpcodeCPUID
LES r16, m16:16o16 C4 /r8086+
LES r32, m16:32o32 C4 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn lfence(&mut self) -> Result<(), IcedError>
where Self: CodeAsmLfence,

LFENCE instruction

InstructionOpcodeCPUID
LFENCENP 0F AE E8SSE2
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn lfs<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLfs<T, U>,

LFS instruction

InstructionOpcodeCPUID
LFS r16, m16:16o16 0F B4 /r386+
LFS r32, m16:32o32 0F B4 /r386+
LFS r64, m16:64o64 0F B4 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn lgdt<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLgdt<T>,

LGDT instruction

InstructionOpcodeCPUID
LGDT m16&640F 01 /2X64
LGDT m16&32o16 0F 01 /2286+
LGDT m16&32o32 0F 01 /2386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn lgs<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLgs<T, U>,

LGS instruction

InstructionOpcodeCPUID
LGS r16, m16:16o16 0F B5 /r386+
LGS r32, m16:32o32 0F B5 /r386+
LGS r64, m16:64o64 0F B5 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn lidt<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLidt<T>,

LIDT instruction

InstructionOpcodeCPUID
LIDT m16&640F 01 /3X64
LIDT m16&32o16 0F 01 /3286+
LIDT m16&32o32 0F 01 /3386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn lkgs<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLkgs<T>,

LKGS instruction

InstructionOpcodeCPUID
LKGS r/m16o16 F2 0F 00 /6LKGS
LKGS r32/m16o32 F2 0F 00 /6LKGS
LKGS r64/m16F2 o64 0F 00 /6LKGS
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn lldt<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLldt<T>,

LLDT instruction

InstructionOpcodeCPUID
LLDT r/m16o16 0F 00 /2286+
LLDT r32/m16o32 0F 00 /2386+
LLDT r64/m16o64 0F 00 /2X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn llwpcb<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLlwpcb<T>,

LLWPCB instruction

InstructionOpcodeCPUID
LLWPCB r32XOP.L0.X9.W0 12 /0LWP
LLWPCB r64XOP.L0.X9.W1 12 /0LWP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn lmsw<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLmsw<T>,

LMSW instruction

InstructionOpcodeCPUID
LMSW r/m16o16 0F 01 /6286+
LMSW r32/m16o32 0F 01 /6386+
LMSW r64/m16o64 0F 01 /6X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn loadall(&mut self) -> Result<(), IcedError>
where Self: CodeAsmLoadall,

LOADALL instruction

InstructionOpcodeCPUID
LOADALL0F 07386
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn loadiwkey<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLoadiwkey<T, U>,

LOADIWKEY instruction

InstructionOpcodeCPUID
LOADIWKEY xmm1, xmm2, <EAX>, <XMM0>F3 0F 38 DC 11:rrr:bbbKL
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn lodsb(&mut self) -> Result<(), IcedError>
where Self: CodeAsmLodsb,

LODSB instruction

InstructionOpcodeCPUID
LODSBAC8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn lodsd(&mut self) -> Result<(), IcedError>
where Self: CodeAsmLodsd,

LODSD instruction

InstructionOpcodeCPUID
LODSDo32 AD386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn lodsq(&mut self) -> Result<(), IcedError>
where Self: CodeAsmLodsq,

LODSQ instruction

InstructionOpcodeCPUID
LODSQo64 ADX64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn lodsw(&mut self) -> Result<(), IcedError>
where Self: CodeAsmLodsw,

LODSW instruction

InstructionOpcodeCPUID
LODSWo16 AD8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn loop_<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLoop<T>,

LOOP instruction

InstructionOpcodeCPUID
LOOP rel8a16 o16 E2 cb8086+
LOOP rel8a32 o32 E2 cb386+
LOOP rel8a64 o64 E2 cbX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn loope<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLoope<T>,

LOOPE instruction

InstructionOpcodeCPUID
LOOPE rel8a16 o16 E1 cb8086+
LOOPE rel8a32 o32 E1 cb386+
LOOPE rel8a64 o64 E1 cbX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn loopne<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLoopne<T>,

LOOPNE instruction

InstructionOpcodeCPUID
LOOPNE rel8a16 o16 E0 cb8086+
LOOPNE rel8a32 o32 E0 cb386+
LOOPNE rel8a64 o64 E0 cbX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn loopnz<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLoopnz<T>,

LOOPNZ instruction

InstructionOpcodeCPUID
LOOPNE rel8a16 o16 E0 cb8086+
LOOPNE rel8a32 o32 E0 cb386+
LOOPNE rel8a64 o64 E0 cbX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn loopz<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLoopz<T>,

LOOPZ instruction

InstructionOpcodeCPUID
LOOPE rel8a16 o16 E1 cb8086+
LOOPE rel8a32 o32 E1 cb386+
LOOPE rel8a64 o64 E1 cbX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn lsl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLsl<T, U>,

LSL instruction

InstructionOpcodeCPUID
LSL r16, r/m16o16 0F 03 /r286+
LSL r32, r32/m16o32 0F 03 /r386+
LSL r64, r64/m16o64 0F 03 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn lss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLss<T, U>,

LSS instruction

InstructionOpcodeCPUID
LSS r16, m16:16o16 0F B2 /r386+
LSS r32, m16:32o32 0F B2 /r386+
LSS r64, m16:64o64 0F B2 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ltr<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmLtr<T>,

LTR instruction

InstructionOpcodeCPUID
LTR r/m16o16 0F 00 /3286+
LTR r32/m16o32 0F 00 /3386+
LTR r64/m16o64 0F 00 /3X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn lwpins<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmLwpins<T, U, V>,

LWPINS instruction

InstructionOpcodeCPUID
LWPINS r32, r/m32, imm32XOP.L0.XA.W0 12 /0 idLWP
LWPINS r64, r/m32, imm32XOP.L0.XA.W1 12 /0 idLWP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn lwpval<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmLwpval<T, U, V>,

LWPVAL instruction

InstructionOpcodeCPUID
LWPVAL r32, r/m32, imm32XOP.L0.XA.W0 12 /1 idLWP
LWPVAL r64, r/m32, imm32XOP.L0.XA.W1 12 /1 idLWP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn lzcnt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmLzcnt<T, U>,

LZCNT instruction

InstructionOpcodeCPUID
LZCNT r16, r/m16o16 F3 0F BD /rLZCNT
LZCNT r32, r/m32o32 F3 0F BD /rLZCNT
LZCNT r64, r/m64F3 o64 0F BD /rLZCNT
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn maskmovdqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMaskmovdqu<T, U>,

MASKMOVDQU instruction

InstructionOpcodeCPUID
MASKMOVDQU xmm1, xmm266 0F F7 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn maskmovq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMaskmovq<T, U>,

MASKMOVQ instruction

InstructionOpcodeCPUID
MASKMOVQ mm1, mm2NP 0F F7 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn maxpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMaxpd<T, U>,

MAXPD instruction

InstructionOpcodeCPUID
MAXPD xmm1, xmm2/m12866 0F 5F /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn maxps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMaxps<T, U>,

MAXPS instruction

InstructionOpcodeCPUID
MAXPS xmm1, xmm2/m128NP 0F 5F /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn maxsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMaxsd<T, U>,

MAXSD instruction

InstructionOpcodeCPUID
MAXSD xmm1, xmm2/m64F2 0F 5F /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn maxss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMaxss<T, U>,

MAXSS instruction

InstructionOpcodeCPUID
MAXSS xmm1, xmm2/m32F3 0F 5F /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn mcommit(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMcommit,

MCOMMIT instruction

InstructionOpcodeCPUID
MCOMMITF3 0F 01 FAMCOMMIT
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn mfence(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMfence,

MFENCE instruction

InstructionOpcodeCPUID
MFENCENP 0F AE F0SSE2
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn minpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMinpd<T, U>,

MINPD instruction

InstructionOpcodeCPUID
MINPD xmm1, xmm2/m12866 0F 5D /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn minps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMinps<T, U>,

MINPS instruction

InstructionOpcodeCPUID
MINPS xmm1, xmm2/m128NP 0F 5D /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn minsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMinsd<T, U>,

MINSD instruction

InstructionOpcodeCPUID
MINSD xmm1, xmm2/m64F2 0F 5D /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn minss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMinss<T, U>,

MINSS instruction

InstructionOpcodeCPUID
MINSS xmm1, xmm2/m32F3 0F 5D /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn monitor(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMonitor,

MONITOR instruction

InstructionOpcodeCPUID
MONITORa16 NP 0F 01 C8MONITOR
MONITORa32 NP 0F 01 C8MONITOR
MONITORa64 NP 0F 01 C8MONITOR
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn monitorx(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMonitorx,

MONITORX instruction

InstructionOpcodeCPUID
MONITORXa16 NP 0F 01 FAMONITORX
MONITORXa32 NP 0F 01 FAMONITORX
MONITORXa64 NP 0F 01 FAMONITORX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn montmul(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMontmul,

MONTMUL instruction

InstructionOpcodeCPUID
MONTMULa16 F3 0F A6 C0PADLOCK_PMM
MONTMULa32 F3 0F A6 C0PADLOCK_PMM
MONTMULa64 F3 0F A6 C0PADLOCK_PMM
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn mov<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMov<T, U>,

MOV instruction

InstructionOpcodeCPUID
MOV r/m8, r888 /r8086+
MOV r/m16, r16o16 89 /r8086+
MOV r/m32, r32o32 89 /r386+
MOV r/m64, r64o64 89 /rX64
MOV r8, r/m88A /r8086+
MOV r16, r/m16o16 8B /r8086+
MOV r32, r/m32o32 8B /r386+
MOV r64, r/m64o64 8B /rX64
MOV r/m16, Srego16 8C /r8086+
MOV r32/m16, Srego32 8C /r386+
MOV r64/m16, Srego64 8C /rX64
MOV Sreg, r/m16o16 8E /r8086+
MOV Sreg, r32/m16o32 8E /r386+
MOV Sreg, r64/m16o64 8E /rX64
MOV AL, moffs8A0 mo8086+
MOV AX, moffs16o16 A1 mo8086+
MOV EAX, moffs32o32 A1 mo386+
MOV RAX, moffs64o64 A1 moX64
MOV moffs8, ALA2 mo8086+
MOV moffs16, AXo16 A3 mo8086+
MOV moffs32, EAXo32 A3 mo386+
MOV moffs64, RAXo64 A3 moX64
MOV r8, imm8B0+rb ib8086+
MOV r16, imm16o16 B8+rw iw8086+
MOV r32, imm32o32 B8+rd id386+
MOV r64, imm64o64 B8+ro ioX64
MOV r/m8, imm8C6 /0 ib8086+
MOV r/m16, imm16o16 C7 /0 iw8086+
MOV r/m32, imm32o32 C7 /0 id386+
MOV r/m64, imm32o64 C7 /0 idX64
MOV r32, cr0F 20 /r386+
MOV r64, cr0F 20 /rX64
MOV r32, dr0F 21 /r386+
MOV r64, dr0F 21 /rX64
MOV cr, r320F 22 /r386+
MOV cr, r640F 22 /rX64
MOV dr, r320F 23 /r386+
MOV dr, r640F 23 /rX64
MOV r32, tr0F 24 /r386/486/Cyrix/Geode
MOV tr, r320F 26 /r386/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
Source

pub fn movapd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovapd<T, U>,

MOVAPD instruction

InstructionOpcodeCPUID
MOVAPD xmm1, xmm2/m12866 0F 28 /rSSE2
MOVAPD xmm2/m128, xmm166 0F 29 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movaps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovaps<T, U>,

MOVAPS instruction

InstructionOpcodeCPUID
MOVAPS xmm1, xmm2/m128NP 0F 28 /rSSE
MOVAPS xmm2/m128, xmm1NP 0F 29 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movbe<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovbe<T, U>,

MOVBE instruction

InstructionOpcodeCPUID
MOVBE r16, m16o16 0F 38 F0 /rMOVBE
MOVBE r32, m32o32 0F 38 F0 /rMOVBE
MOVBE r64, m64o64 0F 38 F0 /rMOVBE
MOVBE m16, r16o16 0F 38 F1 /rMOVBE
MOVBE m32, r32o32 0F 38 F1 /rMOVBE
MOVBE m64, r64o64 0F 38 F1 /rMOVBE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovd<T, U>,

MOVD instruction

InstructionOpcodeCPUID
MOVD mm, r/m32NP 0F 6E /rMMX
MOVD xmm, r/m3266 0F 6E /rSSE2
MOVD r/m32, mmNP 0F 7E /rMMX
MOVD r/m32, xmm66 0F 7E /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movddup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovddup<T, U>,

MOVDDUP instruction

InstructionOpcodeCPUID
MOVDDUP xmm1, xmm2/m64F2 0F 12 /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movdir64b<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovdir64b<T, U>,

MOVDIR64B instruction

InstructionOpcodeCPUID
MOVDIR64B r16, m512a16 66 0F 38 F8 /rMOVDIR64B
MOVDIR64B r32, m512a32 66 0F 38 F8 /rMOVDIR64B
MOVDIR64B r64, m512a64 66 0F 38 F8 /rMOVDIR64B
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movdiri<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovdiri<T, U>,

MOVDIRI instruction

InstructionOpcodeCPUID
MOVDIRI m32, r32NP 0F 38 F9 /rMOVDIRI
MOVDIRI m64, r64NP o64 0F 38 F9 /rMOVDIRI
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movdq2q<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovdq2q<T, U>,

MOVDQ2Q instruction

InstructionOpcodeCPUID
MOVDQ2Q mm, xmmF2 0F D6 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movdqa<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovdqa<T, U>,

MOVDQA instruction

InstructionOpcodeCPUID
MOVDQA xmm1, xmm2/m12866 0F 6F /rSSE2
MOVDQA xmm2/m128, xmm166 0F 7F /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movdqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovdqu<T, U>,

MOVDQU instruction

InstructionOpcodeCPUID
MOVDQU xmm1, xmm2/m128F3 0F 6F /rSSE2
MOVDQU xmm2/m128, xmm1F3 0F 7F /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movhlps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovhlps<T, U>,

MOVHLPS instruction

InstructionOpcodeCPUID
MOVHLPS xmm1, xmm2NP 0F 12 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movhpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovhpd<T, U>,

MOVHPD instruction

InstructionOpcodeCPUID
MOVHPD xmm1, m6466 0F 16 /rSSE2
MOVHPD m64, xmm166 0F 17 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movhps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovhps<T, U>,

MOVHPS instruction

InstructionOpcodeCPUID
MOVHPS xmm1, m64NP 0F 16 /rSSE
MOVHPS m64, xmm1NP 0F 17 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movlhps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovlhps<T, U>,

MOVLHPS instruction

InstructionOpcodeCPUID
MOVLHPS xmm1, xmm2NP 0F 16 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movlpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovlpd<T, U>,

MOVLPD instruction

InstructionOpcodeCPUID
MOVLPD xmm1, m6466 0F 12 /rSSE2
MOVLPD m64, xmm166 0F 13 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movlps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovlps<T, U>,

MOVLPS instruction

InstructionOpcodeCPUID
MOVLPS xmm1, m64NP 0F 12 /rSSE
MOVLPS m64, xmm1NP 0F 13 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movmskpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovmskpd<T, U>,

MOVMSKPD instruction

InstructionOpcodeCPUID
MOVMSKPD r32, xmm66 0F 50 /rSSE2
MOVMSKPD r64, xmm66 o64 0F 50 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movmskps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovmskps<T, U>,

MOVMSKPS instruction

InstructionOpcodeCPUID
MOVMSKPS r32, xmmNP 0F 50 /rSSE
MOVMSKPS r64, xmmNP o64 0F 50 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movntdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovntdq<T, U>,

MOVNTDQ instruction

InstructionOpcodeCPUID
MOVNTDQ m128, xmm166 0F E7 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movntdqa<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovntdqa<T, U>,

MOVNTDQA instruction

InstructionOpcodeCPUID
MOVNTDQA xmm1, m12866 0F 38 2A /rSSE4.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
Source

pub fn movnti<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovnti<T, U>,

MOVNTI instruction

InstructionOpcodeCPUID
MOVNTI m32, r32NP 0F C3 /rSSE2
MOVNTI m64, r64NP o64 0F C3 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movntpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovntpd<T, U>,

MOVNTPD instruction

InstructionOpcodeCPUID
MOVNTPD m128, xmm166 0F 2B /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movntps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovntps<T, U>,

MOVNTPS instruction

InstructionOpcodeCPUID
MOVNTPS m128, xmm1NP 0F 2B /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movntq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovntq<T, U>,

MOVNTQ instruction

InstructionOpcodeCPUID
MOVNTQ m64, mmNP 0F E7 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movntsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovntsd<T, U>,

MOVNTSD instruction

InstructionOpcodeCPUID
MOVNTSD m64, xmm1F2 0F 2B /rSSE4A
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movntss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovntss<T, U>,

MOVNTSS instruction

InstructionOpcodeCPUID
MOVNTSS m32, xmm1F3 0F 2B /rSSE4A
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovq<T, U>,

MOVQ instruction

InstructionOpcodeCPUID
MOVQ mm, r/m64NP o64 0F 6E /rMMX
MOVQ xmm, r/m6466 o64 0F 6E /rSSE2
MOVQ mm, mm/m64NP 0F 6F /rMMX
MOVQ r/m64, mmNP o64 0F 7E /rMMX
MOVQ r/m64, xmm66 o64 0F 7E /rSSE2
MOVQ xmm1, xmm2/m64F3 0F 7E /rSSE2
MOVQ mm/m64, mmNP 0F 7F /rMMX
MOVQ xmm2/m64, xmm166 0F D6 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movq2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovq2dq<T, U>,

MOVQ2DQ instruction

InstructionOpcodeCPUID
MOVQ2DQ xmm, mmF3 0F D6 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movsb(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMovsb,

MOVSB instruction

InstructionOpcodeCPUID
MOVSBA48086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn movsd(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMovsd,

MOVSD instruction

InstructionOpcodeCPUID
MOVSDo32 A5386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn movsd_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovsd2<T, U>,

MOVSD instruction

InstructionOpcodeCPUID
MOVSD xmm1, xmm2/m64F2 0F 10 /rSSE2
MOVSD xmm1/m64, xmm2F2 0F 11 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movshdup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovshdup<T, U>,

MOVSHDUP instruction

InstructionOpcodeCPUID
MOVSHDUP xmm1, xmm2/m128F3 0F 16 /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movsldup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovsldup<T, U>,

MOVSLDUP instruction

InstructionOpcodeCPUID
MOVSLDUP xmm1, xmm2/m128F3 0F 12 /rSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movsq(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMovsq,

MOVSQ instruction

InstructionOpcodeCPUID
MOVSQo64 A5X64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn movss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovss<T, U>,

MOVSS instruction

InstructionOpcodeCPUID
MOVSS xmm1, xmm2/m32F3 0F 10 /rSSE
MOVSS xmm2/m32, xmm1F3 0F 11 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movsw(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMovsw,

MOVSW instruction

InstructionOpcodeCPUID
MOVSWo16 A58086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn movsx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovsx<T, U>,

MOVSX instruction

InstructionOpcodeCPUID
MOVSX r16, r/m8o16 0F BE /r386+
MOVSX r32, r/m8o32 0F BE /r386+
MOVSX r64, r/m8o64 0F BE /rX64
MOVSX r16, r/m16o16 0F BF /r386+
MOVSX r32, r/m16o32 0F BF /r386+
MOVSX r64, r/m16o64 0F BF /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movsxd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovsxd<T, U>,

MOVSXD instruction

InstructionOpcodeCPUID
MOVSXD r16, r/m16o16 63 /rX64
MOVSXD r32, r/m32o32 63 /rX64
MOVSXD r64, r/m32o64 63 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movupd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovupd<T, U>,

MOVUPD instruction

InstructionOpcodeCPUID
MOVUPD xmm1, xmm2/m12866 0F 10 /rSSE2
MOVUPD xmm2/m128, xmm166 0F 11 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movups<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovups<T, U>,

MOVUPS instruction

InstructionOpcodeCPUID
MOVUPS xmm1, xmm2/m128NP 0F 10 /rSSE
MOVUPS xmm2/m128, xmm1NP 0F 11 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn movzx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMovzx<T, U>,

MOVZX instruction

InstructionOpcodeCPUID
MOVZX r16, r/m8o16 0F B6 /r386+
MOVZX r32, r/m8o32 0F B6 /r386+
MOVZX r64, r/m8o64 0F B6 /rX64
MOVZX r16, r/m16o16 0F B7 /r386+
MOVZX r32, r/m16o32 0F B7 /r386+
MOVZX r64, r/m16o64 0F B7 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn mpsadbw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmMpsadbw<T, U, V>,

MPSADBW instruction

InstructionOpcodeCPUID
MPSADBW xmm1, xmm2/m128, imm866 0F 3A 42 /r ibSSE4.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
Source

pub fn mul<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmMul<T>,

MUL instruction

InstructionOpcodeCPUID
MUL r/m8F6 /48086+
MUL r/m16o16 F7 /48086+
MUL r/m32o32 F7 /4386+
MUL r/m64o64 F7 /4X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn mulpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMulpd<T, U>,

MULPD instruction

InstructionOpcodeCPUID
MULPD xmm1, xmm2/m12866 0F 59 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn mulps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMulps<T, U>,

MULPS instruction

InstructionOpcodeCPUID
MULPS xmm1, xmm2/m128NP 0F 59 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn mulsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMulsd<T, U>,

MULSD instruction

InstructionOpcodeCPUID
MULSD xmm1, xmm2/m64F2 0F 59 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn mulss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmMulss<T, U>,

MULSS instruction

InstructionOpcodeCPUID
MULSS xmm1, xmm2/m32F3 0F 59 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn mulx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmMulx<T, U, V>,

MULX instruction

InstructionOpcodeCPUID
MULX r32a, r32b, r/m32VEX.LZ.F2.0F38.W0 F6 /rBMI2
MULX r64a, r64b, r/m64VEX.LZ.F2.0F38.W1 F6 /rBMI2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn mwait(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMwait,

MWAIT instruction

InstructionOpcodeCPUID
MWAITNP 0F 01 C9MONITOR
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn mwaitx(&mut self) -> Result<(), IcedError>
where Self: CodeAsmMwaitx,

MWAITX instruction

InstructionOpcodeCPUID
MWAITXNP 0F 01 FBMONITORX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn neg<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmNeg<T>,

NEG instruction

InstructionOpcodeCPUID
NEG r/m8F6 /38086+
NEG r/m16o16 F7 /38086+
NEG r/m32o32 F7 /3386+
NEG r/m64o64 F7 /3X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn nop(&mut self) -> Result<(), IcedError>
where Self: CodeAsmNop,

NOP instruction

InstructionOpcodeCPUID
NOPo16 908086+
NOPo32 908086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn nop_1<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmNop1<T>,

NOP instruction

InstructionOpcodeCPUID
NOP r/m16o16 0F 1F /0CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
NOP r/m32o32 0F 1F /0CPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
NOP r/m64o64 0F 1F /0CPUID.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)
Source

pub fn not<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmNot<T>,

NOT instruction

InstructionOpcodeCPUID
NOT r/m8F6 /28086+
NOT r/m16o16 F7 /28086+
NOT r/m32o32 F7 /2386+
NOT r/m64o64 F7 /2X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn or<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmOr<T, U>,

OR instruction

InstructionOpcodeCPUID
OR r/m8, r808 /r8086+
OR r/m16, r16o16 09 /r8086+
OR r/m32, r32o32 09 /r386+
OR r/m64, r64o64 09 /rX64
OR r8, r/m80A /r8086+
OR r16, r/m16o16 0B /r8086+
OR r32, r/m32o32 0B /r386+
OR r64, r/m64o64 0B /rX64
OR AL, imm80C ib8086+
OR AX, imm16o16 0D iw8086+
OR EAX, imm32o32 0D id386+
OR RAX, imm32o64 0D idX64
OR r/m8, imm880 /1 ib8086+
OR r/m16, imm16o16 81 /1 iw8086+
OR r/m32, imm32o32 81 /1 id386+
OR r/m64, imm32o64 81 /1 idX64
OR r/m16, imm8o16 83 /1 ib8086+
OR r/m32, imm8o32 83 /1 ib386+
OR r/m64, imm8o64 83 /1 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn orpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmOrpd<T, U>,

ORPD instruction

InstructionOpcodeCPUID
ORPD xmm1, xmm2/m12866 0F 56 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn orps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmOrps<T, U>,

ORPS instruction

InstructionOpcodeCPUID
ORPS xmm1, xmm2/m128NP 0F 56 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn out<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmOut<T, U>,

OUT instruction

InstructionOpcodeCPUID
OUT imm8, ALE6 ib8086+
OUT imm8, AXo16 E7 ib8086+
OUT imm8, EAXo32 E7 ib386+
OUT DX, ALEE8086+
OUT DX, AXo16 EF8086+
OUT DX, EAXo32 EF386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn outsb(&mut self) -> Result<(), IcedError>
where Self: CodeAsmOutsb,

OUTSB instruction

InstructionOpcodeCPUID
OUTSB6E186+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn outsd(&mut self) -> Result<(), IcedError>
where Self: CodeAsmOutsd,

OUTSD instruction

InstructionOpcodeCPUID
OUTSDo32 6F386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn outsw(&mut self) -> Result<(), IcedError>
where Self: CodeAsmOutsw,

OUTSW instruction

InstructionOpcodeCPUID
OUTSWo16 6F186+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pabsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPabsb<T, U>,

PABSB instruction

InstructionOpcodeCPUID
PABSB mm1, mm2/m64NP 0F 38 1C /rSSSE3
PABSB xmm1, xmm2/m12866 0F 38 1C /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pabsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPabsd<T, U>,

PABSD instruction

InstructionOpcodeCPUID
PABSD mm1, mm2/m64NP 0F 38 1E /rSSSE3
PABSD xmm1, xmm2/m12866 0F 38 1E /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pabsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPabsw<T, U>,

PABSW instruction

InstructionOpcodeCPUID
PABSW mm1, mm2/m64NP 0F 38 1D /rSSSE3
PABSW xmm1, xmm2/m12866 0F 38 1D /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn packssdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPackssdw<T, U>,

PACKSSDW instruction

InstructionOpcodeCPUID
PACKSSDW mm1, mm2/m64NP 0F 6B /rMMX
PACKSSDW xmm1, xmm2/m12866 0F 6B /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn packsswb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPacksswb<T, U>,

PACKSSWB instruction

InstructionOpcodeCPUID
PACKSSWB mm1, mm2/m64NP 0F 63 /rMMX
PACKSSWB xmm1, xmm2/m12866 0F 63 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn packusdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPackusdw<T, U>,

PACKUSDW instruction

InstructionOpcodeCPUID
PACKUSDW xmm1, xmm2/m12866 0F 38 2B /rSSE4.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
Source

pub fn packuswb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPackuswb<T, U>,

PACKUSWB instruction

InstructionOpcodeCPUID
PACKUSWB mm, mm/m64NP 0F 67 /rMMX
PACKUSWB xmm1, xmm2/m12866 0F 67 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn paddb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaddb<T, U>,

PADDB instruction

InstructionOpcodeCPUID
PADDB mm, mm/m64NP 0F FC /rMMX
PADDB xmm1, xmm2/m12866 0F FC /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn paddd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaddd<T, U>,

PADDD instruction

InstructionOpcodeCPUID
PADDD mm, mm/m64NP 0F FE /rMMX
PADDD xmm1, xmm2/m12866 0F FE /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn paddq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaddq<T, U>,

PADDQ instruction

InstructionOpcodeCPUID
PADDQ mm, mm/m64NP 0F D4 /rMMX
PADDQ xmm1, xmm2/m12866 0F D4 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn paddsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaddsb<T, U>,

PADDSB instruction

InstructionOpcodeCPUID
PADDSB mm, mm/m64NP 0F EC /rMMX
PADDSB xmm1, xmm2/m12866 0F EC /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn paddsiw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaddsiw<T, U>,

PADDSIW instruction

InstructionOpcodeCPUID
PADDSIW mm, mm/m640F 51 /rCYRIX_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
Source

pub fn paddsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaddsw<T, U>,

PADDSW instruction

InstructionOpcodeCPUID
PADDSW mm, mm/m64NP 0F ED /rMMX
PADDSW xmm1, xmm2/m12866 0F ED /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn paddusb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaddusb<T, U>,

PADDUSB instruction

InstructionOpcodeCPUID
PADDUSB mm, mm/m64NP 0F DC /rMMX
PADDUSB xmm1, xmm2/m12866 0F DC /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn paddusw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaddusw<T, U>,

PADDUSW instruction

InstructionOpcodeCPUID
PADDUSW mm, mm/m64NP 0F DD /rMMX
PADDUSW xmm1, xmm2/m12866 0F DD /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn paddw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaddw<T, U>,

PADDW instruction

InstructionOpcodeCPUID
PADDW mm, mm/m64NP 0F FD /rMMX
PADDW xmm1, xmm2/m12866 0F FD /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn palignr<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPalignr<T, U, V>,

PALIGNR instruction

InstructionOpcodeCPUID
PALIGNR mm1, mm2/m64, imm8NP 0F 3A 0F /r ibSSSE3
PALIGNR xmm1, xmm2/m128, imm866 0F 3A 0F /r ibSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn pand<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPand<T, U>,

PAND instruction

InstructionOpcodeCPUID
PAND mm, mm/m64NP 0F DB /rMMX
PAND xmm1, xmm2/m12866 0F DB /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pandn<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPandn<T, U>,

PANDN instruction

InstructionOpcodeCPUID
PANDN mm, mm/m64NP 0F DF /rMMX
PANDN xmm1, xmm2/m12866 0F DF /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pause(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPause,

PAUSE instruction

InstructionOpcodeCPUID
PAUSEF3 90Pentium 4 or later
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn paveb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPaveb<T, U>,

PAVEB instruction

InstructionOpcodeCPUID
PAVEB mm, mm/m640F 50 /rCYRIX_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
Source

pub fn pavgb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPavgb<T, U>,

PAVGB instruction

InstructionOpcodeCPUID
PAVGB mm1, mm2/m64NP 0F E0 /rSSE
PAVGB xmm1, xmm2/m12866 0F E0 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pavgusb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPavgusb<T, U>,

PAVGUSB instruction

InstructionOpcodeCPUID
PAVGUSB mm, mm/m640F 0F /r BF3DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pavgw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPavgw<T, U>,

PAVGW instruction

InstructionOpcodeCPUID
PAVGW mm1, mm2/m64NP 0F E3 /rSSE
PAVGW xmm1, xmm2/m12866 0F E3 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pblendvb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPblendvb<T, U>,

PBLENDVB instruction

InstructionOpcodeCPUID
PBLENDVB xmm1, xmm2/m128, <XMM0>66 0F 38 10 /rSSE4.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
Source

pub fn pblendw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPblendw<T, U, V>,

PBLENDW instruction

InstructionOpcodeCPUID
PBLENDW xmm1, xmm2/m128, imm866 0F 3A 0E /r ibSSE4.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
Source

pub fn pbndkb(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPbndkb,

PBNDKB instruction

InstructionOpcodeCPUID
PBNDKBNP 0F 01 C7TSE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pclmulhqhqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPclmulhqhqdq<T, U>,

PCLMULHQHQDQ instruction

InstructionOpcodeCPUID
PCLMULQDQ xmm1, xmm2/m128, imm866 0F 3A 44 /r ibPCLMULQDQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pclmulhqlqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPclmulhqlqdq<T, U>,

PCLMULHQLQDQ instruction

InstructionOpcodeCPUID
PCLMULQDQ xmm1, xmm2/m128, imm866 0F 3A 44 /r ibPCLMULQDQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pclmullqhqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPclmullqhqdq<T, U>,

PCLMULLQHQDQ instruction

InstructionOpcodeCPUID
PCLMULQDQ xmm1, xmm2/m128, imm866 0F 3A 44 /r ibPCLMULQDQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pclmullqlqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPclmullqlqdq<T, U>,

PCLMULLQLQDQ instruction

InstructionOpcodeCPUID
PCLMULQDQ xmm1, xmm2/m128, imm866 0F 3A 44 /r ibPCLMULQDQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pclmulqdq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPclmulqdq<T, U, V>,

PCLMULQDQ instruction

InstructionOpcodeCPUID
PCLMULQDQ xmm1, xmm2/m128, imm866 0F 3A 44 /r ibPCLMULQDQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn pcmpeqb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPcmpeqb<T, U>,

PCMPEQB instruction

InstructionOpcodeCPUID
PCMPEQB mm, mm/m64NP 0F 74 /rMMX
PCMPEQB xmm1, xmm2/m12866 0F 74 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pcmpeqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPcmpeqd<T, U>,

PCMPEQD instruction

InstructionOpcodeCPUID
PCMPEQD mm, mm/m64NP 0F 76 /rMMX
PCMPEQD xmm1, xmm2/m12866 0F 76 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pcmpeqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPcmpeqq<T, U>,

PCMPEQQ instruction

InstructionOpcodeCPUID
PCMPEQQ xmm1, xmm2/m12866 0F 38 29 /rSSE4.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
Source

pub fn pcmpeqw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPcmpeqw<T, U>,

PCMPEQW instruction

InstructionOpcodeCPUID
PCMPEQW mm, mm/m64NP 0F 75 /rMMX
PCMPEQW xmm1, xmm2/m12866 0F 75 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pcmpestri<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPcmpestri<T, U, V>,

PCMPESTRI instruction

InstructionOpcodeCPUID
PCMPESTRI xmm1, xmm2/m128, imm866 0F 3A 61 /r ibSSE4.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
Source

pub fn pcmpestri64<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPcmpestri64<T, U, V>,

PCMPESTRI64 instruction

InstructionOpcodeCPUID
PCMPESTRI64 xmm1, xmm2/m128, imm866 o64 0F 3A 61 /r ibSSE4.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
Source

pub fn pcmpestrm<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPcmpestrm<T, U, V>,

PCMPESTRM instruction

InstructionOpcodeCPUID
PCMPESTRM xmm1, xmm2/m128, imm866 0F 3A 60 /r ibSSE4.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
Source

pub fn pcmpestrm64<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPcmpestrm64<T, U, V>,

PCMPESTRM64 instruction

InstructionOpcodeCPUID
PCMPESTRM64 xmm1, xmm2/m128, imm866 o64 0F 3A 60 /r ibSSE4.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
Source

pub fn pcmpgtb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPcmpgtb<T, U>,

PCMPGTB instruction

InstructionOpcodeCPUID
PCMPGTB mm, mm/m64NP 0F 64 /rMMX
PCMPGTB xmm1, xmm2/m12866 0F 64 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pcmpgtd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPcmpgtd<T, U>,

PCMPGTD instruction

InstructionOpcodeCPUID
PCMPGTD mm, mm/m64NP 0F 66 /rMMX
PCMPGTD xmm1, xmm2/m12866 0F 66 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pcmpgtq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPcmpgtq<T, U>,

PCMPGTQ instruction

InstructionOpcodeCPUID
PCMPGTQ xmm1, xmm2/m12866 0F 38 37 /rSSE4.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
Source

pub fn pcmpgtw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPcmpgtw<T, U>,

PCMPGTW instruction

InstructionOpcodeCPUID
PCMPGTW mm, mm/m64NP 0F 65 /rMMX
PCMPGTW xmm1, xmm2/m12866 0F 65 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pcmpistri<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPcmpistri<T, U, V>,

PCMPISTRI instruction

InstructionOpcodeCPUID
PCMPISTRI xmm1, xmm2/m128, imm866 0F 3A 63 /r ibSSE4.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
Source

pub fn pcmpistrm<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPcmpistrm<T, U, V>,

PCMPISTRM instruction

InstructionOpcodeCPUID
PCMPISTRM xmm1, xmm2/m128, imm866 0F 3A 62 /r ibSSE4.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
Source

pub fn pcommit(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPcommit,

PCOMMIT instruction

InstructionOpcodeCPUID
PCOMMIT66 0F AE F8PCOMMIT
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pconfig(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPconfig,

PCONFIG instruction

InstructionOpcodeCPUID
PCONFIGNP 0F 01 C5PCONFIG
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pdep<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmPdep<T, U, V>,

PDEP instruction

InstructionOpcodeCPUID
PDEP r32a, r32b, r/m32VEX.LZ.F2.0F38.W0 F5 /rBMI2
PDEP r64a, r64b, r/m64VEX.LZ.F2.0F38.W1 F5 /rBMI2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn pdistib<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPdistib<T, U>,

PDISTIB instruction

InstructionOpcodeCPUID
PDISTIB mm, m640F 54 /rCYRIX_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
Source

pub fn pext<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmPext<T, U, V>,

PEXT instruction

InstructionOpcodeCPUID
PEXT r32a, r32b, r/m32VEX.LZ.F3.0F38.W0 F5 /rBMI2
PEXT r64a, r64b, r/m64VEX.LZ.F3.0F38.W1 F5 /rBMI2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn pextrb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPextrb<T, U, V>,

PEXTRB instruction

InstructionOpcodeCPUID
PEXTRB r32/m8, xmm2, imm866 0F 3A 14 /r ibSSE4.1
PEXTRB r64/m8, xmm2, imm866 o64 0F 3A 14 /r ibSSE4.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
Source

pub fn pextrd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPextrd<T, U, V>,

PEXTRD instruction

InstructionOpcodeCPUID
PEXTRD r/m32, xmm2, imm866 0F 3A 16 /r ibSSE4.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
Source

pub fn pextrq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPextrq<T, U, V>,

PEXTRQ instruction

InstructionOpcodeCPUID
PEXTRQ r/m64, xmm2, imm866 o64 0F 3A 16 /r ibSSE4.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
Source

pub fn pextrw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPextrw<T, U, V>,

PEXTRW instruction

InstructionOpcodeCPUID
PEXTRW r32, mm, imm8NP 0F C5 /r ibSSE
PEXTRW r64, mm, imm8NP o64 0F C5 /r ibSSE
PEXTRW r32, xmm, imm866 0F C5 /r ibSSE2
PEXTRW r64, xmm, imm866 o64 0F C5 /r ibSSE2
PEXTRW r32/m16, xmm, imm866 0F 3A 15 /r ibSSE4.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
Source

pub fn pf2id<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPf2id<T, U>,

PF2ID instruction

InstructionOpcodeCPUID
PF2ID mm, mm/m640F 0F /r 1D3DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pf2iw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPf2iw<T, U>,

PF2IW instruction

InstructionOpcodeCPUID
PF2IW mm, mm/m640F 0F /r 1C3DNOWEXT
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfacc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfacc<T, U>,

PFACC instruction

InstructionOpcodeCPUID
PFACC mm, mm/m640F 0F /r AE3DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfadd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfadd<T, U>,

PFADD instruction

InstructionOpcodeCPUID
PFADD mm, mm/m640F 0F /r 9E3DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfcmpeq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfcmpeq<T, U>,

PFCMPEQ instruction

InstructionOpcodeCPUID
PFCMPEQ mm, mm/m640F 0F /r B03DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfcmpge<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfcmpge<T, U>,

PFCMPGE instruction

InstructionOpcodeCPUID
PFCMPGE mm, mm/m640F 0F /r 903DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfcmpgt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfcmpgt<T, U>,

PFCMPGT instruction

InstructionOpcodeCPUID
PFCMPGT mm, mm/m640F 0F /r A03DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfmax<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfmax<T, U>,

PFMAX instruction

InstructionOpcodeCPUID
PFMAX mm, mm/m640F 0F /r A43DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfmin<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfmin<T, U>,

PFMIN instruction

InstructionOpcodeCPUID
PFMIN mm, mm/m640F 0F /r 943DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfmul<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfmul<T, U>,

PFMUL instruction

InstructionOpcodeCPUID
PFMUL mm, mm/m640F 0F /r B43DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfnacc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfnacc<T, U>,

PFNACC instruction

InstructionOpcodeCPUID
PFNACC mm, mm/m640F 0F /r 8A3DNOWEXT
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfpnacc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfpnacc<T, U>,

PFPNACC instruction

InstructionOpcodeCPUID
PFPNACC mm, mm/m640F 0F /r 8E3DNOWEXT
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfrcp<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfrcp<T, U>,

PFRCP instruction

InstructionOpcodeCPUID
PFRCP mm, mm/m640F 0F /r 963DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfrcpit1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfrcpit1<T, U>,

PFRCPIT1 instruction

InstructionOpcodeCPUID
PFRCPIT1 mm, mm/m640F 0F /r A63DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfrcpit2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfrcpit2<T, U>,

PFRCPIT2 instruction

InstructionOpcodeCPUID
PFRCPIT2 mm, mm/m640F 0F /r B63DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfrcpv<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfrcpv<T, U>,

PFRCPV instruction

InstructionOpcodeCPUID
PFRCPV mm, mm/m640F 0F /r 86AMD 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
Source

pub fn pfrsqit1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfrsqit1<T, U>,

PFRSQIT1 instruction

InstructionOpcodeCPUID
PFRSQIT1 mm, mm/m640F 0F /r A73DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfrsqrt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfrsqrt<T, U>,

PFRSQRT instruction

InstructionOpcodeCPUID
PFRSQRT mm, mm/m640F 0F /r 973DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfrsqrtv<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfrsqrtv<T, U>,

PFRSQRTV instruction

InstructionOpcodeCPUID
PFRSQRTV mm, mm/m640F 0F /r 87AMD 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
Source

pub fn pfsub<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfsub<T, U>,

PFSUB instruction

InstructionOpcodeCPUID
PFSUB mm, mm/m640F 0F /r 9A3DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pfsubr<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPfsubr<T, U>,

PFSUBR instruction

InstructionOpcodeCPUID
PFSUBR mm, mm/m640F 0F /r AA3DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn phaddd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPhaddd<T, U>,

PHADDD instruction

InstructionOpcodeCPUID
PHADDD mm1, mm2/m64NP 0F 38 02 /rSSSE3
PHADDD xmm1, xmm2/m12866 0F 38 02 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn phaddsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPhaddsw<T, U>,

PHADDSW instruction

InstructionOpcodeCPUID
PHADDSW mm1, mm2/m64NP 0F 38 03 /rSSSE3
PHADDSW xmm1, xmm2/m12866 0F 38 03 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn phaddw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPhaddw<T, U>,

PHADDW instruction

InstructionOpcodeCPUID
PHADDW mm1, mm2/m64NP 0F 38 01 /rSSSE3
PHADDW xmm1, xmm2/m12866 0F 38 01 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn phminposuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPhminposuw<T, U>,

PHMINPOSUW instruction

InstructionOpcodeCPUID
PHMINPOSUW xmm1, xmm2/m12866 0F 38 41 /rSSE4.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
Source

pub fn phsubd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPhsubd<T, U>,

PHSUBD instruction

InstructionOpcodeCPUID
PHSUBD mm1, mm2/m64NP 0F 38 06 /rSSSE3
PHSUBD xmm1, xmm2/m12866 0F 38 06 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn phsubsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPhsubsw<T, U>,

PHSUBSW instruction

InstructionOpcodeCPUID
PHSUBSW mm1, mm2/m64NP 0F 38 07 /rSSSE3
PHSUBSW xmm1, xmm2/m12866 0F 38 07 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn phsubw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPhsubw<T, U>,

PHSUBW instruction

InstructionOpcodeCPUID
PHSUBW mm1, mm2/m64NP 0F 38 05 /rSSSE3
PHSUBW xmm1, xmm2/m12866 0F 38 05 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pi2fd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPi2fd<T, U>,

PI2FD instruction

InstructionOpcodeCPUID
PI2FD mm, mm/m640F 0F /r 0D3DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pi2fw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPi2fw<T, U>,

PI2FW instruction

InstructionOpcodeCPUID
PI2FW mm, mm/m640F 0F /r 0C3DNOWEXT
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pinsrb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPinsrb<T, U, V>,

PINSRB instruction

InstructionOpcodeCPUID
PINSRB xmm1, r32/m8, imm866 0F 3A 20 /r ibSSE4.1
PINSRB xmm1, r64/m8, imm866 o64 0F 3A 20 /r ibSSE4.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
Source

pub fn pinsrd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPinsrd<T, U, V>,

PINSRD instruction

InstructionOpcodeCPUID
PINSRD xmm1, r/m32, imm866 0F 3A 22 /r ibSSE4.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
Source

pub fn pinsrq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPinsrq<T, U, V>,

PINSRQ instruction

InstructionOpcodeCPUID
PINSRQ xmm1, r/m64, imm866 o64 0F 3A 22 /r ibSSE4.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
Source

pub fn pinsrw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPinsrw<T, U, V>,

PINSRW instruction

InstructionOpcodeCPUID
PINSRW mm, r32/m16, imm8NP 0F C4 /r ibSSE
PINSRW mm, r64/m16, imm8NP o64 0F C4 /r ibSSE
PINSRW xmm, r32/m16, imm866 0F C4 /r ibSSE2
PINSRW xmm, r64/m16, imm866 o64 0F C4 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn pmachriw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmachriw<T, U>,

PMACHRIW instruction

InstructionOpcodeCPUID
PMACHRIW mm, m640F 5E /rCYRIX_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
Source

pub fn pmaddubsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmaddubsw<T, U>,

PMADDUBSW instruction

InstructionOpcodeCPUID
PMADDUBSW mm1, mm2/m64NP 0F 38 04 /rSSSE3
PMADDUBSW xmm1, xmm2/m12866 0F 38 04 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmaddwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmaddwd<T, U>,

PMADDWD instruction

InstructionOpcodeCPUID
PMADDWD mm, mm/m64NP 0F F5 /rMMX
PMADDWD xmm1, xmm2/m12866 0F F5 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmagw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmagw<T, U>,

PMAGW instruction

InstructionOpcodeCPUID
PMAGW mm, mm/m640F 52 /rCYRIX_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
Source

pub fn pmaxsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmaxsb<T, U>,

PMAXSB instruction

InstructionOpcodeCPUID
PMAXSB xmm1, xmm2/m12866 0F 38 3C /rSSE4.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
Source

pub fn pmaxsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmaxsd<T, U>,

PMAXSD instruction

InstructionOpcodeCPUID
PMAXSD xmm1, xmm2/m12866 0F 38 3D /rSSE4.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
Source

pub fn pmaxsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmaxsw<T, U>,

PMAXSW instruction

InstructionOpcodeCPUID
PMAXSW mm1, mm2/m64NP 0F EE /rSSE
PMAXSW xmm1, xmm2/m12866 0F EE /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmaxub<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmaxub<T, U>,

PMAXUB instruction

InstructionOpcodeCPUID
PMAXUB mm1, mm2/m64NP 0F DE /rSSE
PMAXUB xmm1, xmm2/m12866 0F DE /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmaxud<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmaxud<T, U>,

PMAXUD instruction

InstructionOpcodeCPUID
PMAXUD xmm1, xmm2/m12866 0F 38 3F /rSSE4.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
Source

pub fn pmaxuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmaxuw<T, U>,

PMAXUW instruction

InstructionOpcodeCPUID
PMAXUW xmm1, xmm2/m12866 0F 38 3E /rSSE4.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
Source

pub fn pminsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPminsb<T, U>,

PMINSB instruction

InstructionOpcodeCPUID
PMINSB xmm1, xmm2/m12866 0F 38 38 /rSSE4.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
Source

pub fn pminsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPminsd<T, U>,

PMINSD instruction

InstructionOpcodeCPUID
PMINSD xmm1, xmm2/m12866 0F 38 39 /rSSE4.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
Source

pub fn pminsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPminsw<T, U>,

PMINSW instruction

InstructionOpcodeCPUID
PMINSW mm1, mm2/m64NP 0F EA /rSSE
PMINSW xmm1, xmm2/m12866 0F EA /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pminub<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPminub<T, U>,

PMINUB instruction

InstructionOpcodeCPUID
PMINUB mm1, mm2/m64NP 0F DA /rSSE
PMINUB xmm1, xmm2/m12866 0F DA /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pminud<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPminud<T, U>,

PMINUD instruction

InstructionOpcodeCPUID
PMINUD xmm1, xmm2/m12866 0F 38 3B /rSSE4.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
Source

pub fn pminuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPminuw<T, U>,

PMINUW instruction

InstructionOpcodeCPUID
PMINUW xmm1, xmm2/m12866 0F 38 3A /rSSE4.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
Source

pub fn pmovmskb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovmskb<T, U>,

PMOVMSKB instruction

InstructionOpcodeCPUID
PMOVMSKB r32, mmNP 0F D7 /rSSE
PMOVMSKB r64, mmNP o64 0F D7 /rSSE
PMOVMSKB r32, xmm66 0F D7 /rSSE2
PMOVMSKB r64, xmm66 o64 0F D7 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmovsxbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovsxbd<T, U>,

PMOVSXBD instruction

InstructionOpcodeCPUID
PMOVSXBD xmm1, xmm2/m3266 0F 38 21 /rSSE4.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
Source

pub fn pmovsxbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovsxbq<T, U>,

PMOVSXBQ instruction

InstructionOpcodeCPUID
PMOVSXBQ xmm1, xmm2/m1666 0F 38 22 /rSSE4.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
Source

pub fn pmovsxbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovsxbw<T, U>,

PMOVSXBW instruction

InstructionOpcodeCPUID
PMOVSXBW xmm1, xmm2/m6466 0F 38 20 /rSSE4.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
Source

pub fn pmovsxdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovsxdq<T, U>,

PMOVSXDQ instruction

InstructionOpcodeCPUID
PMOVSXDQ xmm1, xmm2/m6466 0F 38 25 /rSSE4.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
Source

pub fn pmovsxwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovsxwd<T, U>,

PMOVSXWD instruction

InstructionOpcodeCPUID
PMOVSXWD xmm1, xmm2/m6466 0F 38 23 /rSSE4.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
Source

pub fn pmovsxwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovsxwq<T, U>,

PMOVSXWQ instruction

InstructionOpcodeCPUID
PMOVSXWQ xmm1, xmm2/m3266 0F 38 24 /rSSE4.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
Source

pub fn pmovzxbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovzxbd<T, U>,

PMOVZXBD instruction

InstructionOpcodeCPUID
PMOVZXBD xmm1, xmm2/m3266 0F 38 31 /rSSE4.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
Source

pub fn pmovzxbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovzxbq<T, U>,

PMOVZXBQ instruction

InstructionOpcodeCPUID
PMOVZXBQ xmm1, xmm2/m1666 0F 38 32 /rSSE4.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
Source

pub fn pmovzxbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovzxbw<T, U>,

PMOVZXBW instruction

InstructionOpcodeCPUID
PMOVZXBW xmm1, xmm2/m6466 0F 38 30 /rSSE4.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
Source

pub fn pmovzxdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovzxdq<T, U>,

PMOVZXDQ instruction

InstructionOpcodeCPUID
PMOVZXDQ xmm1, xmm2/m6466 0F 38 35 /rSSE4.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
Source

pub fn pmovzxwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovzxwd<T, U>,

PMOVZXWD instruction

InstructionOpcodeCPUID
PMOVZXWD xmm1, xmm2/m6466 0F 38 33 /rSSE4.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
Source

pub fn pmovzxwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmovzxwq<T, U>,

PMOVZXWQ instruction

InstructionOpcodeCPUID
PMOVZXWQ xmm1, xmm2/m3266 0F 38 34 /rSSE4.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
Source

pub fn pmuldq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmuldq<T, U>,

PMULDQ instruction

InstructionOpcodeCPUID
PMULDQ xmm1, xmm2/m12866 0F 38 28 /rSSE4.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
Source

pub fn pmulhriw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmulhriw<T, U>,

PMULHRIW instruction

InstructionOpcodeCPUID
PMULHRIW mm, mm/m640F 5D /rCYRIX_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
Source

pub fn pmulhrsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmulhrsw<T, U>,

PMULHRSW instruction

InstructionOpcodeCPUID
PMULHRSW mm1, mm2/m64NP 0F 38 0B /rSSSE3
PMULHRSW xmm1, xmm2/m12866 0F 38 0B /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmulhrw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmulhrw<T, U>,

PMULHRW instruction

InstructionOpcodeCPUID
PMULHRW mm, mm/m640F 0F /r B73DNOW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmulhrw_cyrix<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmulhrw_cyrix<T, U>,

PMULHRW_CYRIX instruction

InstructionOpcodeCPUID
PMULHRW mm, mm/m640F 59 /rCYRIX_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
Source

pub fn pmulhuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmulhuw<T, U>,

PMULHUW instruction

InstructionOpcodeCPUID
PMULHUW mm1, mm2/m64NP 0F E4 /rSSE
PMULHUW xmm1, xmm2/m12866 0F E4 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmulhw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmulhw<T, U>,

PMULHW instruction

InstructionOpcodeCPUID
PMULHW mm, mm/m64NP 0F E5 /rMMX
PMULHW xmm1, xmm2/m12866 0F E5 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmulld<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmulld<T, U>,

PMULLD instruction

InstructionOpcodeCPUID
PMULLD xmm1, xmm2/m12866 0F 38 40 /rSSE4.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
Source

pub fn pmullw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmullw<T, U>,

PMULLW instruction

InstructionOpcodeCPUID
PMULLW mm, mm/m64NP 0F D5 /rMMX
PMULLW xmm1, xmm2/m12866 0F D5 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmuludq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmuludq<T, U>,

PMULUDQ instruction

InstructionOpcodeCPUID
PMULUDQ mm1, mm2/m64NP 0F F4 /rSSE2
PMULUDQ xmm1, xmm2/m12866 0F F4 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pmvgezb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmvgezb<T, U>,

PMVGEZB instruction

InstructionOpcodeCPUID
PMVGEZB mm, m640F 5C /rCYRIX_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
Source

pub fn pmvlzb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmvlzb<T, U>,

PMVLZB instruction

InstructionOpcodeCPUID
PMVLZB mm, m640F 5B /rCYRIX_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
Source

pub fn pmvnzb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmvnzb<T, U>,

PMVNZB instruction

InstructionOpcodeCPUID
PMVNZB mm, m640F 5A /rCYRIX_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
Source

pub fn pmvzb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPmvzb<T, U>,

PMVZB instruction

InstructionOpcodeCPUID
PMVZB mm, m640F 58 /rCYRIX_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
Source

pub fn pop<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPop<T>,

POP instruction

InstructionOpcodeCPUID
POP ESo16 078086+
POP ESo32 07386+
POP SSo16 178086+
POP SSo32 17386+
POP DSo16 1F8086+
POP DSo32 1F386+
POP r16o16 58+rw8086+
POP r32o32 58+rd386+
POP r64o64 58+roX64
POP r/m16o16 8F /08086+
POP r/m32o32 8F /0386+
POP r/m64o64 8F /0X64
POP FSo16 0F A1386+
POP FSo32 0F A1386+
POP FSo64 0F A1X64
POP GSo16 0F A9386+
POP GSo32 0F A9386+
POP GSo64 0F A9X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn popa(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPopa,

POPA instruction

InstructionOpcodeCPUID
POPAo16 61186+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn popad(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPopad,

POPAD instruction

InstructionOpcodeCPUID
POPADo32 61386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn popcnt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPopcnt<T, U>,

POPCNT instruction

InstructionOpcodeCPUID
POPCNT r16, r/m16o16 F3 0F B8 /rPOPCNT
POPCNT r32, r/m32o32 F3 0F B8 /rPOPCNT
POPCNT r64, r/m64F3 o64 0F B8 /rPOPCNT
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn popf(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPopf,

POPF instruction

InstructionOpcodeCPUID
POPFo16 9D8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn popfd(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPopfd,

POPFD instruction

InstructionOpcodeCPUID
POPFDo32 9D386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn popfq(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPopfq,

POPFQ instruction

InstructionOpcodeCPUID
POPFQo64 9DX64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn por<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPor<T, U>,

POR instruction

InstructionOpcodeCPUID
POR mm, mm/m64NP 0F EB /rMMX
POR xmm1, xmm2/m12866 0F EB /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn prefetch<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPrefetch<T>,

PREFETCH instruction

InstructionOpcodeCPUID
PREFETCH m80F 0D /0PREFETCHW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn prefetchit0<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPrefetchit0<T>,

PREFETCHIT0 instruction

InstructionOpcodeCPUID
PREFETCHIT0 m80F 18 /7PREFETCHITI
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn prefetchit1<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPrefetchit1<T>,

PREFETCHIT1 instruction

InstructionOpcodeCPUID
PREFETCHIT1 m80F 18 /6PREFETCHITI
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn prefetchnta<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPrefetchnta<T>,

PREFETCHNTA instruction

InstructionOpcodeCPUID
PREFETCHNTA m80F 18 /0SSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn prefetcht0<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPrefetcht0<T>,

PREFETCHT0 instruction

InstructionOpcodeCPUID
PREFETCHT0 m80F 18 /1SSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn prefetcht1<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPrefetcht1<T>,

PREFETCHT1 instruction

InstructionOpcodeCPUID
PREFETCHT1 m80F 18 /2SSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn prefetcht2<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPrefetcht2<T>,

PREFETCHT2 instruction

InstructionOpcodeCPUID
PREFETCHT2 m80F 18 /3SSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn prefetchw<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPrefetchw<T>,

PREFETCHW instruction

InstructionOpcodeCPUID
PREFETCHW m80F 0D /1PREFETCHW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn prefetchwt1<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPrefetchwt1<T>,

PREFETCHWT1 instruction

InstructionOpcodeCPUID
PREFETCHWT1 m80F 0D /2PREFETCHWT1
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn psadbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsadbw<T, U>,

PSADBW instruction

InstructionOpcodeCPUID
PSADBW mm1, mm2/m64NP 0F F6 /rSSE
PSADBW xmm1, xmm2/m12866 0F F6 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pshufb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPshufb<T, U>,

PSHUFB instruction

InstructionOpcodeCPUID
PSHUFB mm1, mm2/m64NP 0F 38 00 /rSSSE3
PSHUFB xmm1, xmm2/m12866 0F 38 00 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pshufd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPshufd<T, U, V>,

PSHUFD instruction

InstructionOpcodeCPUID
PSHUFD xmm1, xmm2/m128, imm866 0F 70 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn pshufhw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPshufhw<T, U, V>,

PSHUFHW instruction

InstructionOpcodeCPUID
PSHUFHW xmm1, xmm2/m128, imm8F3 0F 70 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn pshuflw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPshuflw<T, U, V>,

PSHUFLW instruction

InstructionOpcodeCPUID
PSHUFLW xmm1, xmm2/m128, imm8F2 0F 70 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn pshufw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmPshufw<T, U, V>,

PSHUFW instruction

InstructionOpcodeCPUID
PSHUFW mm1, mm2/m64, imm8NP 0F 70 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn psignb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsignb<T, U>,

PSIGNB instruction

InstructionOpcodeCPUID
PSIGNB mm1, mm2/m64NP 0F 38 08 /rSSSE3
PSIGNB xmm1, xmm2/m12866 0F 38 08 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psignd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsignd<T, U>,

PSIGND instruction

InstructionOpcodeCPUID
PSIGND mm1, mm2/m64NP 0F 38 0A /rSSSE3
PSIGND xmm1, xmm2/m12866 0F 38 0A /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psignw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsignw<T, U>,

PSIGNW instruction

InstructionOpcodeCPUID
PSIGNW mm1, mm2/m64NP 0F 38 09 /rSSSE3
PSIGNW xmm1, xmm2/m12866 0F 38 09 /rSSSE3
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pslld<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPslld<T, U>,

PSLLD instruction

InstructionOpcodeCPUID
PSLLD mm, imm8NP 0F 72 /6 ibMMX
PSLLD xmm1, imm866 0F 72 /6 ibSSE2
PSLLD mm, mm/m64NP 0F F2 /rMMX
PSLLD xmm1, xmm2/m12866 0F F2 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pslldq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPslldq<T, U>,

PSLLDQ instruction

InstructionOpcodeCPUID
PSLLDQ xmm1, imm866 0F 73 /7 ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psllq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsllq<T, U>,

PSLLQ instruction

InstructionOpcodeCPUID
PSLLQ mm, imm8NP 0F 73 /6 ibMMX
PSLLQ xmm1, imm866 0F 73 /6 ibSSE2
PSLLQ mm, mm/m64NP 0F F3 /rMMX
PSLLQ xmm1, xmm2/m12866 0F F3 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psllw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsllw<T, U>,

PSLLW instruction

InstructionOpcodeCPUID
PSLLW mm1, imm8NP 0F 71 /6 ibMMX
PSLLW xmm1, imm866 0F 71 /6 ibSSE2
PSLLW mm, mm/m64NP 0F F1 /rMMX
PSLLW xmm1, xmm2/m12866 0F F1 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psmash(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPsmash,

PSMASH instruction

InstructionOpcodeCPUID
PSMASHF3 0F 01 FFSEV-SNP
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn psrad<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsrad<T, U>,

PSRAD instruction

InstructionOpcodeCPUID
PSRAD mm, imm8NP 0F 72 /4 ibMMX
PSRAD xmm1, imm866 0F 72 /4 ibSSE2
PSRAD mm, mm/m64NP 0F E2 /rMMX
PSRAD xmm1, xmm2/m12866 0F E2 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psraw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsraw<T, U>,

PSRAW instruction

InstructionOpcodeCPUID
PSRAW mm, imm8NP 0F 71 /4 ibMMX
PSRAW xmm1, imm866 0F 71 /4 ibSSE2
PSRAW mm, mm/m64NP 0F E1 /rMMX
PSRAW xmm1, xmm2/m12866 0F E1 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psrld<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsrld<T, U>,

PSRLD instruction

InstructionOpcodeCPUID
PSRLD mm, imm8NP 0F 72 /2 ibMMX
PSRLD xmm1, imm866 0F 72 /2 ibSSE2
PSRLD mm, mm/m64NP 0F D2 /rMMX
PSRLD xmm1, xmm2/m12866 0F D2 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psrldq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsrldq<T, U>,

PSRLDQ instruction

InstructionOpcodeCPUID
PSRLDQ xmm1, imm866 0F 73 /3 ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psrlq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsrlq<T, U>,

PSRLQ instruction

InstructionOpcodeCPUID
PSRLQ mm, imm8NP 0F 73 /2 ibMMX
PSRLQ xmm1, imm866 0F 73 /2 ibSSE2
PSRLQ mm, mm/m64NP 0F D3 /rMMX
PSRLQ xmm1, xmm2/m12866 0F D3 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psrlw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsrlw<T, U>,

PSRLW instruction

InstructionOpcodeCPUID
PSRLW mm, imm8NP 0F 71 /2 ibMMX
PSRLW xmm1, imm866 0F 71 /2 ibSSE2
PSRLW mm, mm/m64NP 0F D1 /rMMX
PSRLW xmm1, xmm2/m12866 0F D1 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psubb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsubb<T, U>,

PSUBB instruction

InstructionOpcodeCPUID
PSUBB mm, mm/m64NP 0F F8 /rMMX
PSUBB xmm1, xmm2/m12866 0F F8 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psubd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsubd<T, U>,

PSUBD instruction

InstructionOpcodeCPUID
PSUBD mm, mm/m64NP 0F FA /rMMX
PSUBD xmm1, xmm2/m12866 0F FA /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psubq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsubq<T, U>,

PSUBQ instruction

InstructionOpcodeCPUID
PSUBQ mm1, mm2/m64NP 0F FB /rSSE2
PSUBQ xmm1, xmm2/m12866 0F FB /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psubsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsubsb<T, U>,

PSUBSB instruction

InstructionOpcodeCPUID
PSUBSB mm, mm/m64NP 0F E8 /rMMX
PSUBSB xmm1, xmm2/m12866 0F E8 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psubsiw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsubsiw<T, U>,

PSUBSIW instruction

InstructionOpcodeCPUID
PSUBSIW mm, mm/m640F 55 /rCYRIX_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
Source

pub fn psubsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsubsw<T, U>,

PSUBSW instruction

InstructionOpcodeCPUID
PSUBSW mm, mm/m64NP 0F E9 /rMMX
PSUBSW xmm1, xmm2/m12866 0F E9 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psubusb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsubusb<T, U>,

PSUBUSB instruction

InstructionOpcodeCPUID
PSUBUSB mm, mm/m64NP 0F D8 /rMMX
PSUBUSB xmm1, xmm2/m12866 0F D8 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psubusw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsubusw<T, U>,

PSUBUSW instruction

InstructionOpcodeCPUID
PSUBUSW mm, mm/m64NP 0F D9 /rMMX
PSUBUSW xmm1, xmm2/m12866 0F D9 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn psubw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPsubw<T, U>,

PSUBW instruction

InstructionOpcodeCPUID
PSUBW mm, mm/m64NP 0F F9 /rMMX
PSUBW xmm1, xmm2/m12866 0F F9 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn pswapd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPswapd<T, U>,

PSWAPD instruction

InstructionOpcodeCPUID
PSWAPD mm, mm/m640F 0F /r BB3DNOWEXT
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ptest<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPtest<T, U>,

PTEST instruction

InstructionOpcodeCPUID
PTEST xmm1, xmm2/m12866 0F 38 17 /rSSE4.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
Source

pub fn ptwrite<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPtwrite<T>,

PTWRITE instruction

InstructionOpcodeCPUID
PTWRITE r/m32F3 0F AE /4PTWRITE
PTWRITE r/m64F3 o64 0F AE /4PTWRITE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn punpckhbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPunpckhbw<T, U>,

PUNPCKHBW instruction

InstructionOpcodeCPUID
PUNPCKHBW mm, mm/m64NP 0F 68 /rMMX
PUNPCKHBW xmm1, xmm2/m12866 0F 68 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn punpckhdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPunpckhdq<T, U>,

PUNPCKHDQ instruction

InstructionOpcodeCPUID
PUNPCKHDQ mm, mm/m64NP 0F 6A /rMMX
PUNPCKHDQ xmm1, xmm2/m12866 0F 6A /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn punpckhqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPunpckhqdq<T, U>,

PUNPCKHQDQ instruction

InstructionOpcodeCPUID
PUNPCKHQDQ xmm1, xmm2/m12866 0F 6D /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn punpckhwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPunpckhwd<T, U>,

PUNPCKHWD instruction

InstructionOpcodeCPUID
PUNPCKHWD mm, mm/m64NP 0F 69 /rMMX
PUNPCKHWD xmm1, xmm2/m12866 0F 69 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn punpcklbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPunpcklbw<T, U>,

PUNPCKLBW instruction

InstructionOpcodeCPUID
PUNPCKLBW mm, mm/m32NP 0F 60 /rMMX
PUNPCKLBW xmm1, xmm2/m12866 0F 60 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn punpckldq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPunpckldq<T, U>,

PUNPCKLDQ instruction

InstructionOpcodeCPUID
PUNPCKLDQ mm, mm/m32NP 0F 62 /rMMX
PUNPCKLDQ xmm1, xmm2/m12866 0F 62 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn punpcklqdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPunpcklqdq<T, U>,

PUNPCKLQDQ instruction

InstructionOpcodeCPUID
PUNPCKLQDQ xmm1, xmm2/m12866 0F 6C /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn punpcklwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPunpcklwd<T, U>,

PUNPCKLWD instruction

InstructionOpcodeCPUID
PUNPCKLWD mm, mm/m32NP 0F 61 /rMMX
PUNPCKLWD xmm1, xmm2/m12866 0F 61 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn push<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmPush<T>,

PUSH instruction

InstructionOpcodeCPUID
PUSH ESo16 068086+
PUSH ESo32 06386+
PUSH CSo16 0E8086+
PUSH CSo32 0E386+
PUSH SSo16 168086+
PUSH SSo32 16386+
PUSH DSo16 1E8086+
PUSH DSo32 1E386+
PUSH r16o16 50+rw8086+
PUSH r32o32 50+rd386+
PUSH r64o64 50+roX64
PUSH imm16o16 68 iw186+
PUSH imm32o32 68 id386+
PUSH imm32o64 68 idX64
PUSH imm8o16 6A ib186+
PUSH imm8o32 6A ib386+
PUSH imm8o64 6A ibX64
PUSH r/m16o16 FF /68086+
PUSH r/m32o32 FF /6386+
PUSH r/m64o64 FF /6X64
PUSH FSo16 0F A0386+
PUSH FSo32 0F A0386+
PUSH FSo64 0F A0X64
PUSH GSo16 0F A8386+
PUSH GSo32 0F A8386+
PUSH GSo64 0F A8X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn pusha(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPusha,

PUSHA instruction

InstructionOpcodeCPUID
PUSHAo16 60186+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pushad(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPushad,

PUSHAD instruction

InstructionOpcodeCPUID
PUSHADo32 60386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pushf(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPushf,

PUSHF instruction

InstructionOpcodeCPUID
PUSHFo16 9C8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pushfd(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPushfd,

PUSHFD instruction

InstructionOpcodeCPUID
PUSHFDo32 9C386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pushfq(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPushfq,

PUSHFQ instruction

InstructionOpcodeCPUID
PUSHFQo64 9CX64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pvalidate(&mut self) -> Result<(), IcedError>
where Self: CodeAsmPvalidate,

PVALIDATE instruction

InstructionOpcodeCPUID
PVALIDATEa16 F2 0F 01 FFSEV-SNP
PVALIDATEa32 F2 0F 01 FFSEV-SNP
PVALIDATEa64 F2 0F 01 FFSEV-SNP
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn pxor<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmPxor<T, U>,

PXOR instruction

InstructionOpcodeCPUID
PXOR mm, mm/m64NP 0F EF /rMMX
PXOR xmm1, xmm2/m12866 0F EF /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn rcl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmRcl<T, U>,

RCL instruction

InstructionOpcodeCPUID
RCL r/m8, imm8C0 /2 ib186+
RCL r/m16, imm8o16 C1 /2 ib186+
RCL r/m32, imm8o32 C1 /2 ib386+
RCL r/m64, imm8o64 C1 /2 ibX64
RCL r/m8, 1D0 /28086+
RCL r/m16, 1o16 D1 /28086+
RCL r/m32, 1o32 D1 /2386+
RCL r/m64, 1o64 D1 /2X64
RCL r/m8, CLD2 /28086+
RCL r/m16, CLo16 D3 /28086+
RCL r/m32, CLo32 D3 /2386+
RCL r/m64, CLo64 D3 /2X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn rcpps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmRcpps<T, U>,

RCPPS instruction

InstructionOpcodeCPUID
RCPPS xmm1, xmm2/m128NP 0F 53 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn rcpss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmRcpss<T, U>,

RCPSS instruction

InstructionOpcodeCPUID
RCPSS xmm1, xmm2/m32F3 0F 53 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn rcr<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmRcr<T, U>,

RCR instruction

InstructionOpcodeCPUID
RCR r/m8, imm8C0 /3 ib186+
RCR r/m16, imm8o16 C1 /3 ib186+
RCR r/m32, imm8o32 C1 /3 ib386+
RCR r/m64, imm8o64 C1 /3 ibX64
RCR r/m8, 1D0 /38086+
RCR r/m16, 1o16 D1 /38086+
RCR r/m32, 1o32 D1 /3386+
RCR r/m64, 1o64 D1 /3X64
RCR r/m8, CLD2 /38086+
RCR r/m16, CLo16 D3 /38086+
RCR r/m32, CLo32 D3 /3386+
RCR r/m64, CLo64 D3 /3X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn rdfsbase<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRdfsbase<T>,

RDFSBASE instruction

InstructionOpcodeCPUID
RDFSBASE r32F3 0F AE /0FSGSBASE
RDFSBASE r64F3 o64 0F AE /0FSGSBASE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn rdgsbase<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRdgsbase<T>,

RDGSBASE instruction

InstructionOpcodeCPUID
RDGSBASE r32F3 0F AE /1FSGSBASE
RDGSBASE r64F3 o64 0F AE /1FSGSBASE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn rdm(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRdm,

RDM instruction

InstructionOpcodeCPUID
RDM0F 3AAMD Geode GX/LX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rdmsr(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRdmsr,

RDMSR instruction

InstructionOpcodeCPUID
RDMSR0F 32MSR
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rdmsrlist(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRdmsrlist,

RDMSRLIST instruction

InstructionOpcodeCPUID
RDMSRLISTF2 0F 01 C6MSRLIST
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rdpid<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRdpid<T>,

RDPID instruction

InstructionOpcodeCPUID
RDPID r32F3 0F C7 /7RDPID
RDPID r64F3 0F C7 /7RDPID
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn rdpkru(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRdpkru,

RDPKRU instruction

InstructionOpcodeCPUID
RDPKRUNP 0F 01 EEPKU
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rdpmc(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRdpmc,

RDPMC instruction

InstructionOpcodeCPUID
RDPMC0F 33Pentium MMX or later, or Pentium Pro or later
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rdpru(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRdpru,

RDPRU instruction

InstructionOpcodeCPUID
RDPRUNP 0F 01 FDRDPRU
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rdrand<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRdrand<T>,

RDRAND instruction

InstructionOpcodeCPUID
RDRAND r16o16 0F C7 /6RDRAND
RDRAND r32o32 0F C7 /6RDRAND
RDRAND r64o64 0F C7 /6RDRAND
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn rdseed<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRdseed<T>,

RDSEED instruction

InstructionOpcodeCPUID
RDSEED r16o16 0F C7 /7RDSEED
RDSEED r32o32 0F C7 /7RDSEED
RDSEED r64o64 0F C7 /7RDSEED
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn rdshr<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRdshr<T>,

RDSHR instruction

InstructionOpcodeCPUID
RDSHR r/m320F 36 /0Cyrix 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)
Source

pub fn rdsspd<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRdsspd<T>,

RDSSPD instruction

InstructionOpcodeCPUID
RDSSPD r32F3 0F 1E /1CET_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)
Source

pub fn rdsspq<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRdsspq<T>,

RDSSPQ instruction

InstructionOpcodeCPUID
RDSSPQ r64F3 o64 0F 1E /1CET_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)
Source

pub fn rdtsc(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRdtsc,

RDTSC instruction

InstructionOpcodeCPUID
RDTSC0F 31TSC
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rdtscp(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRdtscp,

RDTSCP instruction

InstructionOpcodeCPUID
RDTSCP0F 01 F9RDTSCP
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rdudbg(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRdudbg,

RDUDBG instruction

InstructionOpcodeCPUID
RDUDBG0F 0EUDBG
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn reservednop_0f0d<T, U>( &mut self, op0: T, op1: U, ) -> Result<(), IcedError>
where Self: CodeAsmReservednop_0f0d<T, U>,

RESERVEDNOP_0F0D instruction

InstructionOpcodeCPUID
RESERVEDNOP r/m16, r16o16 0F 0D /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32o32 0F 0D /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64o64 0F 0D /rCPUID.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
Source

pub fn reservednop_0f18<T, U>( &mut self, op0: T, op1: U, ) -> Result<(), IcedError>
where Self: CodeAsmReservednop_0f18<T, U>,

RESERVEDNOP_0F18 instruction

InstructionOpcodeCPUID
RESERVEDNOP r/m16, r16o16 0F 18 /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32o32 0F 18 /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64o64 0F 18 /rCPUID.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
Source

pub fn reservednop_0f19<T, U>( &mut self, op0: T, op1: U, ) -> Result<(), IcedError>
where Self: CodeAsmReservednop_0f19<T, U>,

RESERVEDNOP_0F19 instruction

InstructionOpcodeCPUID
RESERVEDNOP r/m16, r16o16 0F 19 /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32o32 0F 19 /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64o64 0F 19 /rCPUID.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
Source

pub fn reservednop_0f1a<T, U>( &mut self, op0: T, op1: U, ) -> Result<(), IcedError>
where Self: CodeAsmReservednop_0f1a<T, U>,

RESERVEDNOP_0F1A instruction

InstructionOpcodeCPUID
RESERVEDNOP r/m16, r16o16 0F 1A /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32o32 0F 1A /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64o64 0F 1A /rCPUID.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
Source

pub fn reservednop_0f1b<T, U>( &mut self, op0: T, op1: U, ) -> Result<(), IcedError>
where Self: CodeAsmReservednop_0f1b<T, U>,

RESERVEDNOP_0F1B instruction

InstructionOpcodeCPUID
RESERVEDNOP r/m16, r16o16 0F 1B /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32o32 0F 1B /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64o64 0F 1B /rCPUID.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
Source

pub fn reservednop_0f1c<T, U>( &mut self, op0: T, op1: U, ) -> Result<(), IcedError>
where Self: CodeAsmReservednop_0f1c<T, U>,

RESERVEDNOP_0F1C instruction

InstructionOpcodeCPUID
RESERVEDNOP r/m16, r16o16 0F 1C /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32o32 0F 1C /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64o64 0F 1C /rCPUID.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
Source

pub fn reservednop_0f1d<T, U>( &mut self, op0: T, op1: U, ) -> Result<(), IcedError>
where Self: CodeAsmReservednop_0f1d<T, U>,

RESERVEDNOP_0F1D instruction

InstructionOpcodeCPUID
RESERVEDNOP r/m16, r16o16 0F 1D /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32o32 0F 1D /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64o64 0F 1D /rCPUID.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
Source

pub fn reservednop_0f1e<T, U>( &mut self, op0: T, op1: U, ) -> Result<(), IcedError>
where Self: CodeAsmReservednop_0f1e<T, U>,

RESERVEDNOP_0F1E instruction

InstructionOpcodeCPUID
RESERVEDNOP r/m16, r16o16 0F 1E /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32o32 0F 1E /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64o64 0F 1E /rCPUID.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
Source

pub fn reservednop_0f1f<T, U>( &mut self, op0: T, op1: U, ) -> Result<(), IcedError>
where Self: CodeAsmReservednop_0f1f<T, U>,

RESERVEDNOP_0F1F instruction

InstructionOpcodeCPUID
RESERVEDNOP r/m16, r16o16 0F 1F /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m32, r32o32 0F 1F /rCPUID.01H.EAX[Bits 11:8] = 0110B or 1111B
RESERVEDNOP r/m64, r64o64 0F 1F /rCPUID.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
Source

pub fn ret(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRet,

RET instruction

InstructionOpcodeCPUID
RETo16 C38086+
RETo32 C3386+
RETo64 C3X64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn ret_1<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRet1<T>,

RET instruction

InstructionOpcodeCPUID
RET imm16o16 C2 iw8086+
RET imm16o32 C2 iw386+
RET imm16o64 C2 iwX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn retf(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRetf,

RETF instruction

InstructionOpcodeCPUID
RETFo16 CB8086+
RETFo32 CB386+
RETFo64 CBX64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn retf_1<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRetf1<T>,

RETF instruction

InstructionOpcodeCPUID
RETF imm16o16 CA iw8086+
RETF imm16o32 CA iw386+
RETF imm16o64 CA iwX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn rmpadjust(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRmpadjust,

RMPADJUST instruction

InstructionOpcodeCPUID
RMPADJUSTF3 0F 01 FESEV-SNP
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rmpquery(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRmpquery,

RMPQUERY instruction

InstructionOpcodeCPUID
RMPQUERYF3 0F 01 FDRMPQUERY
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rmpupdate(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRmpupdate,

RMPUPDATE instruction

InstructionOpcodeCPUID
RMPUPDATEF2 0F 01 FESEV-SNP
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rol<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmRol<T, U>,

ROL instruction

InstructionOpcodeCPUID
ROL r/m8, imm8C0 /0 ib186+
ROL r/m16, imm8o16 C1 /0 ib186+
ROL r/m32, imm8o32 C1 /0 ib386+
ROL r/m64, imm8o64 C1 /0 ibX64
ROL r/m8, 1D0 /08086+
ROL r/m16, 1o16 D1 /08086+
ROL r/m32, 1o32 D1 /0386+
ROL r/m64, 1o64 D1 /0X64
ROL r/m8, CLD2 /08086+
ROL r/m16, CLo16 D3 /08086+
ROL r/m32, CLo32 D3 /0386+
ROL r/m64, CLo64 D3 /0X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ror<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmRor<T, U>,

ROR instruction

InstructionOpcodeCPUID
ROR r/m8, imm8C0 /1 ib186+
ROR r/m16, imm8o16 C1 /1 ib186+
ROR r/m32, imm8o32 C1 /1 ib386+
ROR r/m64, imm8o64 C1 /1 ibX64
ROR r/m8, 1D0 /18086+
ROR r/m16, 1o16 D1 /18086+
ROR r/m32, 1o32 D1 /1386+
ROR r/m64, 1o64 D1 /1X64
ROR r/m8, CLD2 /18086+
ROR r/m16, CLo16 D3 /18086+
ROR r/m32, CLo32 D3 /1386+
ROR r/m64, CLo64 D3 /1X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn rorx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmRorx<T, U, V>,

RORX instruction

InstructionOpcodeCPUID
RORX r32, r/m32, imm8VEX.LZ.F2.0F3A.W0 F0 /r ibBMI2
RORX r64, r/m64, imm8VEX.LZ.F2.0F3A.W1 F0 /r ibBMI2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn roundpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmRoundpd<T, U, V>,

ROUNDPD instruction

InstructionOpcodeCPUID
ROUNDPD xmm1, xmm2/m128, imm866 0F 3A 09 /r ibSSE4.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
Source

pub fn roundps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmRoundps<T, U, V>,

ROUNDPS instruction

InstructionOpcodeCPUID
ROUNDPS xmm1, xmm2/m128, imm866 0F 3A 08 /r ibSSE4.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
Source

pub fn roundsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmRoundsd<T, U, V>,

ROUNDSD instruction

InstructionOpcodeCPUID
ROUNDSD xmm1, xmm2/m64, imm866 0F 3A 0B /r ibSSE4.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
Source

pub fn roundss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmRoundss<T, U, V>,

ROUNDSS instruction

InstructionOpcodeCPUID
ROUNDSS xmm1, xmm2/m32, imm866 0F 3A 0A /r ibSSE4.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
Source

pub fn rsdc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmRsdc<T, U>,

RSDC instruction

InstructionOpcodeCPUID
RSDC Sreg, m800F 79 /rCyrix, 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
Source

pub fn rsldt<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRsldt<T>,

RSLDT instruction

InstructionOpcodeCPUID
RSLDT m800F 7B /0Cyrix, 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)
Source

pub fn rsm(&mut self) -> Result<(), IcedError>
where Self: CodeAsmRsm,

RSM instruction

InstructionOpcodeCPUID
RSM0F AA386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn rsqrtps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmRsqrtps<T, U>,

RSQRTPS instruction

InstructionOpcodeCPUID
RSQRTPS xmm1, xmm2/m128NP 0F 52 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn rsqrtss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmRsqrtss<T, U>,

RSQRTSS instruction

InstructionOpcodeCPUID
RSQRTSS xmm1, xmm2/m32F3 0F 52 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn rstorssp<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRstorssp<T>,

RSTORSSP instruction

InstructionOpcodeCPUID
RSTORSSP m64F3 0F 01 /5CET_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)
Source

pub fn rsts<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmRsts<T>,

RSTS instruction

InstructionOpcodeCPUID
RSTS m800F 7D /0Cyrix, 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)
Source

pub fn sahf(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSahf,

SAHF instruction

InstructionOpcodeCPUID
SAHF9E8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sal<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSal<T, U>,

SAL instruction

InstructionOpcodeCPUID
SAL r/m8, imm8C0 /6 ib186+
SAL r/m16, imm8o16 C1 /6 ib186+
SAL r/m32, imm8o32 C1 /6 ib386+
SAL r/m64, imm8o64 C1 /6 ibX64
SAL r/m8, 1D0 /68086+
SAL r/m16, 1o16 D1 /68086+
SAL r/m32, 1o32 D1 /6386+
SAL r/m64, 1o64 D1 /6X64
SAL r/m8, CLD2 /68086+
SAL r/m16, CLo16 D3 /68086+
SAL r/m32, CLo32 D3 /6386+
SAL r/m64, CLo64 D3 /6X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn salc(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSalc,

SALC instruction

InstructionOpcodeCPUID
SALCD68086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sar<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSar<T, U>,

SAR instruction

InstructionOpcodeCPUID
SAR r/m8, imm8C0 /7 ib186+
SAR r/m16, imm8o16 C1 /7 ib186+
SAR r/m32, imm8o32 C1 /7 ib386+
SAR r/m64, imm8o64 C1 /7 ibX64
SAR r/m8, 1D0 /78086+
SAR r/m16, 1o16 D1 /78086+
SAR r/m32, 1o32 D1 /7386+
SAR r/m64, 1o64 D1 /7X64
SAR r/m8, CLD2 /78086+
SAR r/m16, CLo16 D3 /78086+
SAR r/m32, CLo32 D3 /7386+
SAR r/m64, CLo64 D3 /7X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn sarx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmSarx<T, U, V>,

SARX instruction

InstructionOpcodeCPUID
SARX r32a, r/m32, r32bVEX.LZ.F3.0F38.W0 F7 /rBMI2
SARX r64a, r/m64, r64bVEX.LZ.F3.0F38.W1 F7 /rBMI2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn saveprevssp(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSaveprevssp,

SAVEPREVSSP instruction

InstructionOpcodeCPUID
SAVEPREVSSPF3 0F 01 EACET_SS
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sbb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSbb<T, U>,

SBB instruction

InstructionOpcodeCPUID
SBB r/m8, r818 /r8086+
SBB r/m16, r16o16 19 /r8086+
SBB r/m32, r32o32 19 /r386+
SBB r/m64, r64o64 19 /rX64
SBB r8, r/m81A /r8086+
SBB r16, r/m16o16 1B /r8086+
SBB r32, r/m32o32 1B /r386+
SBB r64, r/m64o64 1B /rX64
SBB AL, imm81C ib8086+
SBB AX, imm16o16 1D iw8086+
SBB EAX, imm32o32 1D id386+
SBB RAX, imm32o64 1D idX64
SBB r/m8, imm880 /3 ib8086+
SBB r/m16, imm16o16 81 /3 iw8086+
SBB r/m32, imm32o32 81 /3 id386+
SBB r/m64, imm32o64 81 /3 idX64
SBB r/m16, imm8o16 83 /3 ib8086+
SBB r/m32, imm8o32 83 /3 ib386+
SBB r/m64, imm8o64 83 /3 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn scasb(&mut self) -> Result<(), IcedError>
where Self: CodeAsmScasb,

SCASB instruction

InstructionOpcodeCPUID
SCASBAE8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn scasd(&mut self) -> Result<(), IcedError>
where Self: CodeAsmScasd,

SCASD instruction

InstructionOpcodeCPUID
SCASDo32 AF386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn scasq(&mut self) -> Result<(), IcedError>
where Self: CodeAsmScasq,

SCASQ instruction

InstructionOpcodeCPUID
SCASQo64 AFX64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn scasw(&mut self) -> Result<(), IcedError>
where Self: CodeAsmScasw,

SCASW instruction

InstructionOpcodeCPUID
SCASWo16 AF8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn seamcall(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSeamcall,

SEAMCALL instruction

InstructionOpcodeCPUID
SEAMCALL66 0F 01 CFTDX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn seamops(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSeamops,

SEAMOPS instruction

InstructionOpcodeCPUID
SEAMOPS66 0F 01 CETDX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn seamret(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSeamret,

SEAMRET instruction

InstructionOpcodeCPUID
SEAMRET66 0F 01 CDTDX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn senduipi<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSenduipi<T>,

SENDUIPI instruction

InstructionOpcodeCPUID
SENDUIPI r64F3 0F C7 /6UINTR
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn serialize(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSerialize,

SERIALIZE instruction

InstructionOpcodeCPUID
SERIALIZENP 0F 01 E8SERIALIZE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn seta<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSeta<T>,

SETA instruction

InstructionOpcodeCPUID
SETA r/m80F 97 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setae<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetae<T>,

SETAE instruction

InstructionOpcodeCPUID
SETAE r/m80F 93 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setb<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetb<T>,

SETB instruction

InstructionOpcodeCPUID
SETB r/m80F 92 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setbe<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetbe<T>,

SETBE instruction

InstructionOpcodeCPUID
SETBE r/m80F 96 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setc<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetc<T>,

SETC instruction

InstructionOpcodeCPUID
SETB r/m80F 92 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn sete<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSete<T>,

SETE instruction

InstructionOpcodeCPUID
SETE r/m80F 94 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setg<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetg<T>,

SETG instruction

InstructionOpcodeCPUID
SETG r/m80F 9F /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setge<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetge<T>,

SETGE instruction

InstructionOpcodeCPUID
SETGE r/m80F 9D /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setl<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetl<T>,

SETL instruction

InstructionOpcodeCPUID
SETL r/m80F 9C /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setle<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetle<T>,

SETLE instruction

InstructionOpcodeCPUID
SETLE r/m80F 9E /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setna<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetna<T>,

SETNA instruction

InstructionOpcodeCPUID
SETBE r/m80F 96 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setnae<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetnae<T>,

SETNAE instruction

InstructionOpcodeCPUID
SETB r/m80F 92 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setnb<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetnb<T>,

SETNB instruction

InstructionOpcodeCPUID
SETAE r/m80F 93 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setnbe<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetnbe<T>,

SETNBE instruction

InstructionOpcodeCPUID
SETA r/m80F 97 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setnc<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetnc<T>,

SETNC instruction

InstructionOpcodeCPUID
SETAE r/m80F 93 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setne<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetne<T>,

SETNE instruction

InstructionOpcodeCPUID
SETNE r/m80F 95 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setng<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetng<T>,

SETNG instruction

InstructionOpcodeCPUID
SETLE r/m80F 9E /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setnge<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetnge<T>,

SETNGE instruction

InstructionOpcodeCPUID
SETL r/m80F 9C /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setnl<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetnl<T>,

SETNL instruction

InstructionOpcodeCPUID
SETGE r/m80F 9D /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setnle<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetnle<T>,

SETNLE instruction

InstructionOpcodeCPUID
SETG r/m80F 9F /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setno<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetno<T>,

SETNO instruction

InstructionOpcodeCPUID
SETNO r/m80F 91 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setnp<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetnp<T>,

SETNP instruction

InstructionOpcodeCPUID
SETNP r/m80F 9B /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setns<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetns<T>,

SETNS instruction

InstructionOpcodeCPUID
SETNS r/m80F 99 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setnz<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetnz<T>,

SETNZ instruction

InstructionOpcodeCPUID
SETNE r/m80F 95 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn seto<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSeto<T>,

SETO instruction

InstructionOpcodeCPUID
SETO r/m80F 90 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setp<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetp<T>,

SETP instruction

InstructionOpcodeCPUID
SETP r/m80F 9A /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setpe<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetpe<T>,

SETPE instruction

InstructionOpcodeCPUID
SETP r/m80F 9A /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setpo<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetpo<T>,

SETPO instruction

InstructionOpcodeCPUID
SETNP r/m80F 9B /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn sets<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSets<T>,

SETS instruction

InstructionOpcodeCPUID
SETS r/m80F 98 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn setssbsy(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSetssbsy,

SETSSBSY instruction

InstructionOpcodeCPUID
SETSSBSYF3 0F 01 E8CET_SS
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn setz<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSetz<T>,

SETZ instruction

InstructionOpcodeCPUID
SETE r/m80F 94 /r386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn sfence(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSfence,

SFENCE instruction

InstructionOpcodeCPUID
SFENCENP 0F AE F8SSE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sgdt<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSgdt<T>,

SGDT instruction

InstructionOpcodeCPUID
SGDT m0F 01 /0X64
SGDT mo16 0F 01 /0286+
SGDT mo32 0F 01 /0386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn sha1msg1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSha1msg1<T, U>,

SHA1MSG1 instruction

InstructionOpcodeCPUID
SHA1MSG1 xmm1, xmm2/m128NP 0F 38 C9 /rSHA
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn sha1msg2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSha1msg2<T, U>,

SHA1MSG2 instruction

InstructionOpcodeCPUID
SHA1MSG2 xmm1, xmm2/m128NP 0F 38 CA /rSHA
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn sha1nexte<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSha1nexte<T, U>,

SHA1NEXTE instruction

InstructionOpcodeCPUID
SHA1NEXTE xmm1, xmm2/m128NP 0F 38 C8 /rSHA
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn sha1rnds4<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmSha1rnds4<T, U, V>,

SHA1RNDS4 instruction

InstructionOpcodeCPUID
SHA1RNDS4 xmm1, xmm2/m128, imm8NP 0F 3A CC /r ibSHA
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn sha256msg1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSha256msg1<T, U>,

SHA256MSG1 instruction

InstructionOpcodeCPUID
SHA256MSG1 xmm1, xmm2/m128NP 0F 38 CC /rSHA
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn sha256msg2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSha256msg2<T, U>,

SHA256MSG2 instruction

InstructionOpcodeCPUID
SHA256MSG2 xmm1, xmm2/m128NP 0F 38 CD /rSHA
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn sha256rnds2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSha256rnds2<T, U>,

SHA256RNDS2 instruction

InstructionOpcodeCPUID
SHA256RNDS2 xmm1, xmm2/m128, <XMM0>NP 0F 38 CB /rSHA
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn shl<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmShl<T, U>,

SHL instruction

InstructionOpcodeCPUID
SHL r/m8, imm8C0 /4 ib186+
SHL r/m16, imm8o16 C1 /4 ib186+
SHL r/m32, imm8o32 C1 /4 ib386+
SHL r/m64, imm8o64 C1 /4 ibX64
SHL r/m8, 1D0 /48086+
SHL r/m16, 1o16 D1 /48086+
SHL r/m32, 1o32 D1 /4386+
SHL r/m64, 1o64 D1 /4X64
SHL r/m8, CLD2 /48086+
SHL r/m16, CLo16 D3 /48086+
SHL r/m32, CLo32 D3 /4386+
SHL r/m64, CLo64 D3 /4X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn shld<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmShld<T, U, V>,

SHLD instruction

InstructionOpcodeCPUID
SHLD r/m16, r16, imm8o16 0F A4 /r ib386+
SHLD r/m32, r32, imm8o32 0F A4 /r ib386+
SHLD r/m64, r64, imm8o64 0F A4 /r ibX64
SHLD r/m16, r16, CLo16 0F A5 /r386+
SHLD r/m32, r32, CLo32 0F A5 /r386+
SHLD r/m64, r64, CLo64 0F A5 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn shlx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmShlx<T, U, V>,

SHLX instruction

InstructionOpcodeCPUID
SHLX r32a, r/m32, r32bVEX.LZ.66.0F38.W0 F7 /rBMI2
SHLX r64a, r/m64, r64bVEX.LZ.66.0F38.W1 F7 /rBMI2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn shr<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmShr<T, U>,

SHR instruction

InstructionOpcodeCPUID
SHR r/m8, imm8C0 /5 ib186+
SHR r/m16, imm8o16 C1 /5 ib186+
SHR r/m32, imm8o32 C1 /5 ib386+
SHR r/m64, imm8o64 C1 /5 ibX64
SHR r/m8, 1D0 /58086+
SHR r/m16, 1o16 D1 /58086+
SHR r/m32, 1o32 D1 /5386+
SHR r/m64, 1o64 D1 /5X64
SHR r/m8, CLD2 /58086+
SHR r/m16, CLo16 D3 /58086+
SHR r/m32, CLo32 D3 /5386+
SHR r/m64, CLo64 D3 /5X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn shrd<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmShrd<T, U, V>,

SHRD instruction

InstructionOpcodeCPUID
SHRD r/m16, r16, imm8o16 0F AC /r ib386+
SHRD r/m32, r32, imm8o32 0F AC /r ib386+
SHRD r/m64, r64, imm8o64 0F AC /r ibX64
SHRD r/m16, r16, CLo16 0F AD /r386+
SHRD r/m32, r32, CLo32 0F AD /r386+
SHRD r/m64, r64, CLo64 0F AD /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn shrx<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmShrx<T, U, V>,

SHRX instruction

InstructionOpcodeCPUID
SHRX r32a, r/m32, r32bVEX.LZ.F2.0F38.W0 F7 /rBMI2
SHRX r64a, r/m64, r64bVEX.LZ.F2.0F38.W1 F7 /rBMI2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn shufpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmShufpd<T, U, V>,

SHUFPD instruction

InstructionOpcodeCPUID
SHUFPD xmm1, xmm2/m128, imm866 0F C6 /r ibSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn shufps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmShufps<T, U, V>,

SHUFPS instruction

InstructionOpcodeCPUID
SHUFPS xmm1, xmm2/m128, imm8NP 0F C6 /r ibSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn sidt<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSidt<T>,

SIDT instruction

InstructionOpcodeCPUID
SIDT m0F 01 /1X64
SIDT mo16 0F 01 /1286+
SIDT mo32 0F 01 /1386+
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn skinit(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSkinit,

SKINIT instruction

InstructionOpcodeCPUID
SKINIT0F 01 DESKINIT or SVM
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sldt<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSldt<T>,

SLDT instruction

InstructionOpcodeCPUID
SLDT r/m16o16 0F 00 /0286+
SLDT r32/m16o32 0F 00 /0386+
SLDT r64/m16o64 0F 00 /0X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn slwpcb<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSlwpcb<T>,

SLWPCB instruction

InstructionOpcodeCPUID
SLWPCB r32XOP.L0.X9.W0 12 /1LWP
SLWPCB r64XOP.L0.X9.W1 12 /1LWP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn smint(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSmint,

SMINT instruction

InstructionOpcodeCPUID
SMINT0F 38Cyrix 6x86MX+, AMD Geode GX/LX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn smint_0f7e(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSmint_0f7e,

SMINT_0F7E instruction

InstructionOpcodeCPUID
SMINT0F 7ECyrix 6x86 or earlier
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn smsw<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSmsw<T>,

SMSW instruction

InstructionOpcodeCPUID
SMSW r/m16o16 0F 01 /4286+
SMSW r32/m16o32 0F 01 /4386+
SMSW r64/m16o64 0F 01 /4X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn sqrtpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSqrtpd<T, U>,

SQRTPD instruction

InstructionOpcodeCPUID
SQRTPD xmm1, xmm2/m12866 0F 51 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn sqrtps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSqrtps<T, U>,

SQRTPS instruction

InstructionOpcodeCPUID
SQRTPS xmm1, xmm2/m128NP 0F 51 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn sqrtsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSqrtsd<T, U>,

SQRTSD instruction

InstructionOpcodeCPUID
SQRTSD xmm1, xmm2/m64F2 0F 51 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn sqrtss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSqrtss<T, U>,

SQRTSS instruction

InstructionOpcodeCPUID
SQRTSS xmm1, xmm2/m32F3 0F 51 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn stac(&mut self) -> Result<(), IcedError>
where Self: CodeAsmStac,

STAC instruction

InstructionOpcodeCPUID
STACNP 0F 01 CBSMAP
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn stc(&mut self) -> Result<(), IcedError>
where Self: CodeAsmStc,

STC instruction

InstructionOpcodeCPUID
STCF98086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn std(&mut self) -> Result<(), IcedError>
where Self: CodeAsmStd,

STD instruction

InstructionOpcodeCPUID
STDFD8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn stgi(&mut self) -> Result<(), IcedError>
where Self: CodeAsmStgi,

STGI instruction

InstructionOpcodeCPUID
STGI0F 01 DCSKINIT or SVM
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sti(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSti,

STI instruction

InstructionOpcodeCPUID
STIFB8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn stmxcsr<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmStmxcsr<T>,

STMXCSR instruction

InstructionOpcodeCPUID
STMXCSR m32NP 0F AE /3SSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn stosb(&mut self) -> Result<(), IcedError>
where Self: CodeAsmStosb,

STOSB instruction

InstructionOpcodeCPUID
STOSBAA8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn stosd(&mut self) -> Result<(), IcedError>
where Self: CodeAsmStosd,

STOSD instruction

InstructionOpcodeCPUID
STOSDo32 AB386+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn stosq(&mut self) -> Result<(), IcedError>
where Self: CodeAsmStosq,

STOSQ instruction

InstructionOpcodeCPUID
STOSQo64 ABX64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn stosw(&mut self) -> Result<(), IcedError>
where Self: CodeAsmStosw,

STOSW instruction

InstructionOpcodeCPUID
STOSWo16 AB8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn str<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmStr<T>,

STR instruction

InstructionOpcodeCPUID
STR r/m16o16 0F 00 /1286+
STR r32/m16o32 0F 00 /1386+
STR r64/m16o64 0F 00 /1X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn sttilecfg<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSttilecfg<T>,

STTILECFG instruction

InstructionOpcodeCPUID
STTILECFG m512VEX.128.66.0F38.W0 49 !(11):000:bbbAMX-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)
Source

pub fn stui(&mut self) -> Result<(), IcedError>
where Self: CodeAsmStui,

STUI instruction

InstructionOpcodeCPUID
STUIF3 0F 01 EFUINTR
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sub<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSub<T, U>,

SUB instruction

InstructionOpcodeCPUID
SUB r/m8, r828 /r8086+
SUB r/m16, r16o16 29 /r8086+
SUB r/m32, r32o32 29 /r386+
SUB r/m64, r64o64 29 /rX64
SUB r8, r/m82A /r8086+
SUB r16, r/m16o16 2B /r8086+
SUB r32, r/m32o32 2B /r386+
SUB r64, r/m64o64 2B /rX64
SUB AL, imm82C ib8086+
SUB AX, imm16o16 2D iw8086+
SUB EAX, imm32o32 2D id386+
SUB RAX, imm32o64 2D idX64
SUB r/m8, imm880 /5 ib8086+
SUB r/m16, imm16o16 81 /5 iw8086+
SUB r/m32, imm32o32 81 /5 id386+
SUB r/m64, imm32o64 81 /5 idX64
SUB r/m16, imm8o16 83 /5 ib8086+
SUB r/m32, imm8o32 83 /5 ib386+
SUB r/m64, imm8o64 83 /5 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn subpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSubpd<T, U>,

SUBPD instruction

InstructionOpcodeCPUID
SUBPD xmm1, xmm2/m12866 0F 5C /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn subps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSubps<T, U>,

SUBPS instruction

InstructionOpcodeCPUID
SUBPS xmm1, xmm2/m128NP 0F 5C /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn subsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSubsd<T, U>,

SUBSD instruction

InstructionOpcodeCPUID
SUBSD xmm1, xmm2/m64F2 0F 5C /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn subss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSubss<T, U>,

SUBSS instruction

InstructionOpcodeCPUID
SUBSS xmm1, xmm2/m32F3 0F 5C /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn svdc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmSvdc<T, U>,

SVDC instruction

InstructionOpcodeCPUID
SVDC m80, Sreg0F 78 /rCyrix, 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
Source

pub fn svldt<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSvldt<T>,

SVLDT instruction

InstructionOpcodeCPUID
SVLDT m800F 7A /0Cyrix, 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)
Source

pub fn svts<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmSvts<T>,

SVTS instruction

InstructionOpcodeCPUID
SVTS m800F 7C /0Cyrix, 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)
Source

pub fn swapgs(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSwapgs,

SWAPGS instruction

InstructionOpcodeCPUID
SWAPGS0F 01 F8X64
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn syscall(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSyscall,

SYSCALL instruction

InstructionOpcodeCPUID
SYSCALL0F 05SYSCALL
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sysenter(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSysenter,

SYSENTER instruction

InstructionOpcodeCPUID
SYSENTER0F 34SEP
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sysexit(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSysexit,

SYSEXIT instruction

InstructionOpcodeCPUID
SYSEXIT0F 35SEP
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sysexitq(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSysexitq,

SYSEXITQ instruction

InstructionOpcodeCPUID
SYSEXITQo64 0F 35SEP
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sysret(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSysret,

SYSRET instruction

InstructionOpcodeCPUID
SYSRET0F 07SYSCALL
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn sysretq(&mut self) -> Result<(), IcedError>
where Self: CodeAsmSysretq,

SYSRETQ instruction

InstructionOpcodeCPUID
SYSRETQo64 0F 07SYSCALL
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn t1mskc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmT1mskc<T, U>,

T1MSKC instruction

InstructionOpcodeCPUID
T1MSKC r32, r/m32XOP.L0.X9.W0 01 /7TBM
T1MSKC r64, r/m64XOP.L0.X9.W1 01 /7TBM
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn tcmmimfp16ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmTcmmimfp16ps<T, U, V>,

TCMMIMFP16PS instruction

InstructionOpcodeCPUID
TCMMIMFP16PS tmm1, tmm2, tmm3VEX.128.66.0F38.W0 6C 11:rrr:bbbAMX-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
Source

pub fn tcmmrlfp16ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmTcmmrlfp16ps<T, U, V>,

TCMMRLFP16PS instruction

InstructionOpcodeCPUID
TCMMRLFP16PS tmm1, tmm2, tmm3VEX.128.0F38.W0 6C 11:rrr:bbbAMX-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
Source

pub fn tdcall(&mut self) -> Result<(), IcedError>
where Self: CodeAsmTdcall,

TDCALL instruction

InstructionOpcodeCPUID
TDCALL66 0F 01 CCTDX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn tdpbf16ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmTdpbf16ps<T, U, V>,

TDPBF16PS instruction

InstructionOpcodeCPUID
TDPBF16PS tmm1, tmm2, tmm3VEX.128.F3.0F38.W0 5C 11:rrr:bbbAMX-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
Source

pub fn tdpbssd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmTdpbssd<T, U, V>,

TDPBSSD instruction

InstructionOpcodeCPUID
TDPBSSD tmm1, tmm2, tmm3VEX.128.F2.0F38.W0 5E 11:rrr:bbbAMX-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
Source

pub fn tdpbsud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmTdpbsud<T, U, V>,

TDPBSUD instruction

InstructionOpcodeCPUID
TDPBSUD tmm1, tmm2, tmm3VEX.128.F3.0F38.W0 5E 11:rrr:bbbAMX-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
Source

pub fn tdpbusd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmTdpbusd<T, U, V>,

TDPBUSD instruction

InstructionOpcodeCPUID
TDPBUSD tmm1, tmm2, tmm3VEX.128.66.0F38.W0 5E 11:rrr:bbbAMX-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
Source

pub fn tdpbuud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmTdpbuud<T, U, V>,

TDPBUUD instruction

InstructionOpcodeCPUID
TDPBUUD tmm1, tmm2, tmm3VEX.128.0F38.W0 5E 11:rrr:bbbAMX-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
Source

pub fn tdpfp16ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmTdpfp16ps<T, U, V>,

TDPFP16PS instruction

InstructionOpcodeCPUID
TDPFP16PS tmm1, tmm2, tmm3VEX.128.F2.0F38.W0 5C 11:rrr:bbbAMX-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn test<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmTest<T, U>,

TEST instruction

InstructionOpcodeCPUID
TEST r/m8, r884 /r8086+
TEST r/m16, r16o16 85 /r8086+
TEST r/m32, r32o32 85 /r386+
TEST r/m64, r64o64 85 /rX64
TEST AL, imm8A8 ib8086+
TEST AX, imm16o16 A9 iw8086+
TEST EAX, imm32o32 A9 id386+
TEST RAX, imm32o64 A9 idX64
TEST r/m8, imm8F6 /0 ib8086+
TEST r/m16, imm16o16 F7 /0 iw8086+
TEST r/m32, imm32o32 F7 /0 id386+
TEST r/m64, imm32o64 F7 /0 idX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn testui(&mut self) -> Result<(), IcedError>
where Self: CodeAsmTestui,

TESTUI instruction

InstructionOpcodeCPUID
TESTUIF3 0F 01 EDUINTR
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn tileloadd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmTileloadd<T, U>,

TILELOADD instruction

InstructionOpcodeCPUID
TILELOADD tmm1, sibmemVEX.128.F2.0F38.W0 4B !(11):rrr:100AMX-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
Source

pub fn tileloaddt1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmTileloaddt1<T, U>,

TILELOADDT1 instruction

InstructionOpcodeCPUID
TILELOADDT1 tmm1, sibmemVEX.128.66.0F38.W0 4B !(11):rrr:100AMX-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
Source

pub fn tilerelease(&mut self) -> Result<(), IcedError>
where Self: CodeAsmTilerelease,

TILERELEASE instruction

InstructionOpcodeCPUID
TILERELEASEVEX.128.0F38.W0 49 C0AMX-TILE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn tilestored<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmTilestored<T, U>,

TILESTORED instruction

InstructionOpcodeCPUID
TILESTORED sibmem, tmm1VEX.128.F3.0F38.W0 4B !(11):rrr:100AMX-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
Source

pub fn tilezero<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmTilezero<T>,

TILEZERO instruction

InstructionOpcodeCPUID
TILEZERO tmm1VEX.128.F2.0F38.W0 49 11:rrr:000AMX-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)
Source

pub fn tlbsync(&mut self) -> Result<(), IcedError>
where Self: CodeAsmTlbsync,

TLBSYNC instruction

InstructionOpcodeCPUID
TLBSYNCNP 0F 01 FFINVLPGB
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn tpause<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmTpause<T>,

TPAUSE instruction

InstructionOpcodeCPUID
TPAUSE r32, <edx>, <eax>66 0F AE /6WAITPKG
TPAUSE r64, <edx>, <eax>66 o64 0F AE /6WAITPKG
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn tzcnt<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmTzcnt<T, U>,

TZCNT instruction

InstructionOpcodeCPUID
TZCNT r16, r/m16o16 F3 0F BC /rBMI1
TZCNT r32, r/m32o32 F3 0F BC /rBMI1
TZCNT r64, r/m64F3 o64 0F BC /rBMI1
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn tzmsk<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmTzmsk<T, U>,

TZMSK instruction

InstructionOpcodeCPUID
TZMSK r32, r/m32XOP.L0.X9.W0 01 /4TBM
TZMSK r64, r/m64XOP.L0.X9.W1 01 /4TBM
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ucomisd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmUcomisd<T, U>,

UCOMISD instruction

InstructionOpcodeCPUID
UCOMISD xmm1, xmm2/m6466 0F 2E /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ucomiss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmUcomiss<T, U>,

UCOMISS instruction

InstructionOpcodeCPUID
UCOMISS xmm1, xmm2/m32NP 0F 2E /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ud0(&mut self) -> Result<(), IcedError>
where Self: CodeAsmUd0,

UD0 instruction

InstructionOpcodeCPUID
UD00F FF286+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn ud0_2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmUd02<T, U>,

UD0 instruction

InstructionOpcodeCPUID
UD0 r16, r/m16o16 0F FF /r286+
UD0 r32, r/m32o32 0F FF /r386+
UD0 r64, r/m64o64 0F FF /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ud1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmUd1<T, U>,

UD1 instruction

InstructionOpcodeCPUID
UD1 r16, r/m16o16 0F B9 /r286+
UD1 r32, r/m32o32 0F B9 /r386+
UD1 r64, r/m64o64 0F B9 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn ud2(&mut self) -> Result<(), IcedError>
where Self: CodeAsmUd2,

UD2 instruction

InstructionOpcodeCPUID
UD20F 0B286+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn uiret(&mut self) -> Result<(), IcedError>
where Self: CodeAsmUiret,

UIRET instruction

InstructionOpcodeCPUID
UIRETF3 0F 01 ECUINTR
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn umonitor<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmUmonitor<T>,

UMONITOR instruction

InstructionOpcodeCPUID
UMONITOR r16a16 F3 0F AE /6WAITPKG
UMONITOR r32a32 F3 0F AE /6WAITPKG
UMONITOR r64a64 F3 0F AE /6WAITPKG
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn umov<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmUmov<T, U>,

UMOV instruction

InstructionOpcodeCPUID
UMOV r/m8, r80F 10 /r386/486
UMOV r/m16, r16o16 0F 11 /r386/486
UMOV r/m32, r32o32 0F 11 /r386/486
UMOV r8, r/m80F 12 /r386/486
UMOV r16, r/m16o16 0F 13 /r386/486
UMOV r32, r/m32o32 0F 13 /r386/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
Source

pub fn umwait<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmUmwait<T>,

UMWAIT instruction

InstructionOpcodeCPUID
UMWAIT r32, <edx>, <eax>F2 0F AE /6WAITPKG
UMWAIT r64, <edx>, <eax>F2 o64 0F AE /6WAITPKG
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn unpckhpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmUnpckhpd<T, U>,

UNPCKHPD instruction

InstructionOpcodeCPUID
UNPCKHPD xmm1, xmm2/m12866 0F 15 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn unpckhps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmUnpckhps<T, U>,

UNPCKHPS instruction

InstructionOpcodeCPUID
UNPCKHPS xmm1, xmm2/m128NP 0F 15 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn unpcklpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmUnpcklpd<T, U>,

UNPCKLPD instruction

InstructionOpcodeCPUID
UNPCKLPD xmm1, xmm2/m12866 0F 14 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn unpcklps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmUnpcklps<T, U>,

UNPCKLPS instruction

InstructionOpcodeCPUID
UNPCKLPS xmm1, xmm2/m128NP 0F 14 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn v4fmaddps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmV4fmaddps<T, U, V>,

V4FMADDPS instruction

InstructionOpcodeCPUID
V4FMADDPS zmm1 {k1}{z}, zmm2+3, m128EVEX.512.F2.0F38.W0 9A /rAVX512_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
Source

pub fn v4fmaddss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmV4fmaddss<T, U, V>,

V4FMADDSS instruction

InstructionOpcodeCPUID
V4FMADDSS xmm1 {k1}{z}, xmm2+3, m128EVEX.LIG.F2.0F38.W0 9B /rAVX512_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
Source

pub fn v4fnmaddps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmV4fnmaddps<T, U, V>,

V4FNMADDPS instruction

InstructionOpcodeCPUID
V4FNMADDPS zmm1 {k1}{z}, zmm2+3, m128EVEX.512.F2.0F38.W0 AA /rAVX512_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
Source

pub fn v4fnmaddss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmV4fnmaddss<T, U, V>,

V4FNMADDSS instruction

InstructionOpcodeCPUID
V4FNMADDSS xmm1 {k1}{z}, xmm2+3, m128EVEX.LIG.F2.0F38.W0 AB /rAVX512_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
Source

pub fn vaddpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaddpd<T, U, V>,

VADDPD instruction

InstructionOpcodeCPUID
VADDPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 58 /rAVX
VADDPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 58 /rAVX
VADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 58 /rAVX512VL AVX512F
VADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 58 /rAVX512VL AVX512F
VADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F.W1 58 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vaddph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaddph<T, U, V>,

VADDPH instruction

InstructionOpcodeCPUID
VADDPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.MAP5.W0 58 /rAVX512VL AVX512-FP16
VADDPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.MAP5.W0 58 /rAVX512VL AVX512-FP16
VADDPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.MAP5.W0 58 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vaddps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaddps<T, U, V>,

VADDPS instruction

InstructionOpcodeCPUID
VADDPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 58 /rAVX
VADDPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 58 /rAVX
VADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 58 /rAVX512VL AVX512F
VADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 58 /rAVX512VL AVX512F
VADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.0F.W0 58 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vaddsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaddsd<T, U, V>,

VADDSD instruction

InstructionOpcodeCPUID
VADDSD xmm1, xmm2, xmm3/m64VEX.LIG.F2.0F.WIG 58 /rAVX
VADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.F2.0F.W1 58 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vaddsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaddsh<T, U, V>,

VADDSH instruction

InstructionOpcodeCPUID
VADDSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.F3.MAP5.W0 58 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vaddss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaddss<T, U, V>,

VADDSS instruction

InstructionOpcodeCPUID
VADDSS xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 58 /rAVX
VADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.F3.0F.W0 58 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vaddsubpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaddsubpd<T, U, V>,

VADDSUBPD instruction

InstructionOpcodeCPUID
VADDSUBPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG D0 /rAVX
VADDSUBPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG D0 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vaddsubps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaddsubps<T, U, V>,

VADDSUBPS instruction

InstructionOpcodeCPUID
VADDSUBPS xmm1, xmm2, xmm3/m128VEX.128.F2.0F.WIG D0 /rAVX
VADDSUBPS ymm1, ymm2, ymm3/m256VEX.256.F2.0F.WIG D0 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vaesdec<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaesdec<T, U, V>,

VAESDEC instruction

InstructionOpcodeCPUID
VAESDEC xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG DE /rAES AVX
VAESDEC ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG DE /rVAES
VAESDEC xmm1, xmm2, xmm3/m128EVEX.128.66.0F38.WIG DE /rAVX512VL VAES
VAESDEC ymm1, ymm2, ymm3/m256EVEX.256.66.0F38.WIG DE /rAVX512VL VAES
VAESDEC zmm1, zmm2, zmm3/m512EVEX.512.66.0F38.WIG DE /rAVX512F 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
Source

pub fn vaesdeclast<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaesdeclast<T, U, V>,

VAESDECLAST instruction

InstructionOpcodeCPUID
VAESDECLAST xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG DF /rAES AVX
VAESDECLAST ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG DF /rVAES
VAESDECLAST xmm1, xmm2, xmm3/m128EVEX.128.66.0F38.WIG DF /rAVX512VL VAES
VAESDECLAST ymm1, ymm2, ymm3/m256EVEX.256.66.0F38.WIG DF /rAVX512VL VAES
VAESDECLAST zmm1, zmm2, zmm3/m512EVEX.512.66.0F38.WIG DF /rAVX512F 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
Source

pub fn vaesenc<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaesenc<T, U, V>,

VAESENC instruction

InstructionOpcodeCPUID
VAESENC xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG DC /rAES AVX
VAESENC ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG DC /rVAES
VAESENC xmm1, xmm2, xmm3/m128EVEX.128.66.0F38.WIG DC /rAVX512VL VAES
VAESENC ymm1, ymm2, ymm3/m256EVEX.256.66.0F38.WIG DC /rAVX512VL VAES
VAESENC zmm1, zmm2, zmm3/m512EVEX.512.66.0F38.WIG DC /rAVX512F 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
Source

pub fn vaesenclast<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaesenclast<T, U, V>,

VAESENCLAST instruction

InstructionOpcodeCPUID
VAESENCLAST xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG DD /rAES AVX
VAESENCLAST ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG DD /rVAES
VAESENCLAST xmm1, xmm2, xmm3/m128EVEX.128.66.0F38.WIG DD /rAVX512VL VAES
VAESENCLAST ymm1, ymm2, ymm3/m256EVEX.256.66.0F38.WIG DD /rAVX512VL VAES
VAESENCLAST zmm1, zmm2, zmm3/m512EVEX.512.66.0F38.WIG DD /rAVX512F 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
Source

pub fn vaesimc<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVaesimc<T, U>,

VAESIMC instruction

InstructionOpcodeCPUID
VAESIMC xmm1, xmm2/m128VEX.128.66.0F38.WIG DB /rAES 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
Source

pub fn vaeskeygenassist<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVaeskeygenassist<T, U, V>,

VAESKEYGENASSIST instruction

InstructionOpcodeCPUID
VAESKEYGENASSIST xmm1, xmm2/m128, imm8VEX.128.66.0F3A.WIG DF /r ibAES 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
Source

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

InstructionOpcodeCPUID
VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 03 /r ibAVX512VL AVX512F
VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 03 /r ibAVX512VL AVX512F
VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 03 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 03 /r ibAVX512VL AVX512F
VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 03 /r ibAVX512VL AVX512F
VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 03 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vandnpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVandnpd<T, U, V>,

VANDNPD instruction

InstructionOpcodeCPUID
VANDNPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 55 /rAVX
VANDNPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 55 /rAVX
VANDNPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 55 /rAVX512VL AVX512DQ
VANDNPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 55 /rAVX512VL AVX512DQ
VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 55 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vandnps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVandnps<T, U, V>,

VANDNPS instruction

InstructionOpcodeCPUID
VANDNPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 55 /rAVX
VANDNPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 55 /rAVX
VANDNPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 55 /rAVX512VL AVX512DQ
VANDNPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 55 /rAVX512VL AVX512DQ
VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.0F.W0 55 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vandpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVandpd<T, U, V>,

VANDPD instruction

InstructionOpcodeCPUID
VANDPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 54 /rAVX
VANDPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 54 /rAVX
VANDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 54 /rAVX512VL AVX512DQ
VANDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 54 /rAVX512VL AVX512DQ
VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 54 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vandps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVandps<T, U, V>,

VANDPS instruction

InstructionOpcodeCPUID
VANDPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 54 /rAVX
VANDPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 54 /rAVX
VANDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 54 /rAVX512VL AVX512DQ
VANDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 54 /rAVX512VL AVX512DQ
VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.0F.W0 54 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vbcstnebf162ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbcstnebf162ps<T, U>,

VBCSTNEBF162PS instruction

InstructionOpcodeCPUID
VBCSTNEBF162PS xmm1, m16VEX.128.F3.0F38.W0 B1 !(11):rrr:bbbAVX-NE-CONVERT
VBCSTNEBF162PS ymm1, m16VEX.256.F3.0F38.W0 B1 !(11):rrr:bbbAVX-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
Source

pub fn vbcstnesh2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbcstnesh2ps<T, U>,

VBCSTNESH2PS instruction

InstructionOpcodeCPUID
VBCSTNESH2PS xmm1, m16VEX.128.66.0F38.W0 B1 !(11):rrr:bbbAVX-NE-CONVERT
VBCSTNESH2PS ymm1, m16VEX.256.66.0F38.W0 B1 !(11):rrr:bbbAVX-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
Source

pub fn vblendmpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVblendmpd<T, U, V>,

VBLENDMPD instruction

InstructionOpcodeCPUID
VBLENDMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 65 /rAVX512VL AVX512F
VBLENDMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 65 /rAVX512VL AVX512F
VBLENDMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 65 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vblendmps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVblendmps<T, U, V>,

VBLENDMPS instruction

InstructionOpcodeCPUID
VBLENDMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 65 /rAVX512VL AVX512F
VBLENDMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 65 /rAVX512VL AVX512F
VBLENDMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 65 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VBLENDPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 0D /r ibAVX
VBLENDPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 0D /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VBLENDPS xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 0C /r ibAVX
VBLENDPS ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 0C /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VBLENDVPD xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 4B /r /is4AVX
VBLENDVPD ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 4B /r /is4AVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VBLENDVPS xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 4A /r /is4AVX
VBLENDVPS ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 4A /r /is4AVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vbroadcastf128<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcastf128<T, U>,

VBROADCASTF128 instruction

InstructionOpcodeCPUID
VBROADCASTF128 ymm1, m128VEX.256.66.0F38.W0 1A /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcastf32x2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcastf32x2<T, U>,

VBROADCASTF32X2 instruction

InstructionOpcodeCPUID
VBROADCASTF32X2 ymm1 {k1}{z}, xmm2/m64EVEX.256.66.0F38.W0 19 /rAVX512VL AVX512DQ
VBROADCASTF32X2 zmm1 {k1}{z}, xmm2/m64EVEX.512.66.0F38.W0 19 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcastf32x4<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcastf32x4<T, U>,

VBROADCASTF32X4 instruction

InstructionOpcodeCPUID
VBROADCASTF32X4 ymm1 {k1}{z}, m128EVEX.256.66.0F38.W0 1A /rAVX512VL AVX512F
VBROADCASTF32X4 zmm1 {k1}{z}, m128EVEX.512.66.0F38.W0 1A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcastf32x8<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcastf32x8<T, U>,

VBROADCASTF32X8 instruction

InstructionOpcodeCPUID
VBROADCASTF32X8 zmm1 {k1}{z}, m256EVEX.512.66.0F38.W0 1B /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcastf64x2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcastf64x2<T, U>,

VBROADCASTF64X2 instruction

InstructionOpcodeCPUID
VBROADCASTF64X2 ymm1 {k1}{z}, m128EVEX.256.66.0F38.W1 1A /rAVX512VL AVX512DQ
VBROADCASTF64X2 zmm1 {k1}{z}, m128EVEX.512.66.0F38.W1 1A /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcastf64x4<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcastf64x4<T, U>,

VBROADCASTF64X4 instruction

InstructionOpcodeCPUID
VBROADCASTF64X4 zmm1 {k1}{z}, m256EVEX.512.66.0F38.W1 1B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcasti128<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcasti128<T, U>,

VBROADCASTI128 instruction

InstructionOpcodeCPUID
VBROADCASTI128 ymm1, m128VEX.256.66.0F38.W0 5A /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcasti32x2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcasti32x2<T, U>,

VBROADCASTI32X2 instruction

InstructionOpcodeCPUID
VBROADCASTI32X2 xmm1 {k1}{z}, xmm2/m64EVEX.128.66.0F38.W0 59 /rAVX512VL AVX512DQ
VBROADCASTI32X2 ymm1 {k1}{z}, xmm2/m64EVEX.256.66.0F38.W0 59 /rAVX512VL AVX512DQ
VBROADCASTI32X2 zmm1 {k1}{z}, xmm2/m64EVEX.512.66.0F38.W0 59 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcasti32x4<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcasti32x4<T, U>,

VBROADCASTI32X4 instruction

InstructionOpcodeCPUID
VBROADCASTI32X4 ymm1 {k1}{z}, m128EVEX.256.66.0F38.W0 5A /rAVX512VL AVX512F
VBROADCASTI32X4 zmm1 {k1}{z}, m128EVEX.512.66.0F38.W0 5A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcasti32x8<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcasti32x8<T, U>,

VBROADCASTI32X8 instruction

InstructionOpcodeCPUID
VBROADCASTI32X8 zmm1 {k1}{z}, m256EVEX.512.66.0F38.W0 5B /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcasti64x2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcasti64x2<T, U>,

VBROADCASTI64X2 instruction

InstructionOpcodeCPUID
VBROADCASTI64X2 ymm1 {k1}{z}, m128EVEX.256.66.0F38.W1 5A /rAVX512VL AVX512DQ
VBROADCASTI64X2 zmm1 {k1}{z}, m128EVEX.512.66.0F38.W1 5A /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcasti64x4<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcasti64x4<T, U>,

VBROADCASTI64X4 instruction

InstructionOpcodeCPUID
VBROADCASTI64X4 zmm1 {k1}{z}, m256EVEX.512.66.0F38.W1 5B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcastsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcastsd<T, U>,

VBROADCASTSD instruction

InstructionOpcodeCPUID
VBROADCASTSD ymm1, m64VEX.256.66.0F38.W0 19 /rAVX
VBROADCASTSD ymm1, xmm2VEX.256.66.0F38.W0 19 /rAVX2
VBROADCASTSD ymm1 {k1}{z}, xmm2/m64EVEX.256.66.0F38.W1 19 /rAVX512VL AVX512F
VBROADCASTSD zmm1 {k1}{z}, xmm2/m64EVEX.512.66.0F38.W1 19 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vbroadcastss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVbroadcastss<T, U>,

VBROADCASTSS instruction

InstructionOpcodeCPUID
VBROADCASTSS xmm1, m32VEX.128.66.0F38.W0 18 /rAVX
VBROADCASTSS xmm1, xmm2VEX.128.66.0F38.W0 18 /rAVX2
VBROADCASTSS ymm1, m32VEX.256.66.0F38.W0 18 /rAVX
VBROADCASTSS ymm1, xmm2VEX.256.66.0F38.W0 18 /rAVX2
VBROADCASTSS xmm1 {k1}{z}, xmm2/m32EVEX.128.66.0F38.W0 18 /rAVX512VL AVX512F
VBROADCASTSS ymm1 {k1}{z}, xmm2/m32EVEX.256.66.0F38.W0 18 /rAVX512VL AVX512F
VBROADCASTSS zmm1 {k1}{z}, xmm2/m32EVEX.512.66.0F38.W0 18 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpeqpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpeqpd<T, U, V>,

VCMPEQPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpeqph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpeqph<T, U, V>,

VCMPEQPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpeqps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpeqps<T, U, V>,

VCMPEQPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpeqsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpeqsd<T, U, V>,

VCMPEQSD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpeqsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpeqsh<T, U, V>,

VCMPEQSH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpeqss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpeqss<T, U, V>,

VCMPEQSS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpfalsepd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpfalsepd<T, U, V>,

VCMPFALSEPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpfalseph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpfalseph<T, U, V>,

VCMPFALSEPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpfalseps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpfalseps<T, U, V>,

VCMPFALSEPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpfalsesd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpfalsesd<T, U, V>,

VCMPFALSESD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpfalsesh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpfalsesh<T, U, V>,

VCMPFALSESH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpfalsess<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpfalsess<T, U, V>,

VCMPFALSESS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgepd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgepd<T, U, V>,

VCMPGEPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgeph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgeph<T, U, V>,

VCMPGEPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgeps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgeps<T, U, V>,

VCMPGEPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgesd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgesd<T, U, V>,

VCMPGESD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgesh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgesh<T, U, V>,

VCMPGESH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgess<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgess<T, U, V>,

VCMPGESS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgtpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgtpd<T, U, V>,

VCMPGTPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgtph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgtph<T, U, V>,

VCMPGTPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgtps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgtps<T, U, V>,

VCMPGTPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgtsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgtsd<T, U, V>,

VCMPGTSD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgtsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgtsh<T, U, V>,

VCMPGTSH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpgtss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpgtss<T, U, V>,

VCMPGTSS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmplepd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmplepd<T, U, V>,

VCMPLEPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpleph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpleph<T, U, V>,

VCMPLEPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpleps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpleps<T, U, V>,

VCMPLEPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmplesd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmplesd<T, U, V>,

VCMPLESD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmplesh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmplesh<T, U, V>,

VCMPLESH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpless<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpless<T, U, V>,

VCMPLESS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpltpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpltpd<T, U, V>,

VCMPLTPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpltph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpltph<T, U, V>,

VCMPLTPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpltps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpltps<T, U, V>,

VCMPLTPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpltsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpltsd<T, U, V>,

VCMPLTSD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpltsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpltsh<T, U, V>,

VCMPLTSH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpltss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpltss<T, U, V>,

VCMPLTSS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpneqpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpneqpd<T, U, V>,

VCMPNEQPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpneqph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpneqph<T, U, V>,

VCMPNEQPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpneqps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpneqps<T, U, V>,

VCMPNEQPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpneqsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpneqsd<T, U, V>,

VCMPNEQSD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpneqsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpneqsh<T, U, V>,

VCMPNEQSH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpneqss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpneqss<T, U, V>,

VCMPNEQSS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngepd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngepd<T, U, V>,

VCMPNGEPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngeph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngeph<T, U, V>,

VCMPNGEPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngeps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngeps<T, U, V>,

VCMPNGEPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngesd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngesd<T, U, V>,

VCMPNGESD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngesh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngesh<T, U, V>,

VCMPNGESH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngess<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngess<T, U, V>,

VCMPNGESS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngtpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngtpd<T, U, V>,

VCMPNGTPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngtph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngtph<T, U, V>,

VCMPNGTPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngtps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngtps<T, U, V>,

VCMPNGTPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngtsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngtsd<T, U, V>,

VCMPNGTSD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngtsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngtsh<T, U, V>,

VCMPNGTSH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpngtss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpngtss<T, U, V>,

VCMPNGTSS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnlepd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnlepd<T, U, V>,

VCMPNLEPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnleph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnleph<T, U, V>,

VCMPNLEPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnleps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnleps<T, U, V>,

VCMPNLEPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnlesd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnlesd<T, U, V>,

VCMPNLESD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnlesh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnlesh<T, U, V>,

VCMPNLESH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnless<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnless<T, U, V>,

VCMPNLESS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnltpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnltpd<T, U, V>,

VCMPNLTPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnltph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnltph<T, U, V>,

VCMPNLTPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnltps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnltps<T, U, V>,

VCMPNLTPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnltsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnltsd<T, U, V>,

VCMPNLTSD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnltsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnltsh<T, U, V>,

VCMPNLTSH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpnltss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpnltss<T, U, V>,

VCMPNLTSS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpordpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpordpd<T, U, V>,

VCMPORDPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpordph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpordph<T, U, V>,

VCMPORDPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpordps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpordps<T, U, V>,

VCMPORDPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpordsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpordsd<T, U, V>,

VCMPORDSD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpordsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpordsh<T, U, V>,

VCMPORDSH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpordss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpordss<T, U, V>,

VCMPORDSS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmptruepd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmptruepd<T, U, V>,

VCMPTRUEPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmptrueph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmptrueph<T, U, V>,

VCMPTRUEPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmptrueps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmptrueps<T, U, V>,

VCMPTRUEPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmptruesd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmptruesd<T, U, V>,

VCMPTRUESD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmptruesh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmptruesh<T, U, V>,

VCMPTRUESH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmptruess<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmptruess<T, U, V>,

VCMPTRUESS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpunordpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpunordpd<T, U, V>,

VCMPUNORDPD instruction

InstructionOpcodeCPUID
VCMPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C2 /r ibAVX
VCMPPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C2 /r ibAVX
VCMPPD k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C2 /r ibAVX512VL AVX512F
VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpunordph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpunordph<T, U, V>,

VCMPUNORDPH instruction

InstructionOpcodeCPUID
VCMPPH k1 {k2}, xmm2, xmm3/m128/m16bcst, imm8EVEX.128.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, ymm2, ymm3/m256/m16bcst, imm8EVEX.256.0F3A.W0 C2 /r ibAVX512VL AVX512-FP16
VCMPPH k1 {k2}, zmm2, zmm3/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpunordps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpunordps<T, U, V>,

VCMPUNORDPS instruction

InstructionOpcodeCPUID
VCMPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C2 /r ibAVX
VCMPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C2 /r ibAVX
VCMPPS k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C2 /r ibAVX512VL AVX512F
VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpunordsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpunordsd<T, U, V>,

VCMPUNORDSD instruction

InstructionOpcodeCPUID
VCMPSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.F2.0F.WIG C2 /r ibAVX
VCMPSD k1 {k2}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.F2.0F.W1 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpunordsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpunordsh<T, U, V>,

VCMPUNORDSH instruction

InstructionOpcodeCPUID
VCMPSH k1 {k2}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.F3.0F3A.W0 C2 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcmpunordss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcmpunordss<T, U, V>,

VCMPUNORDSS instruction

InstructionOpcodeCPUID
VCMPSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.F3.0F.WIG C2 /r ibAVX
VCMPSS k1 {k2}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.F3.0F.W0 C2 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcomisd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcomisd<T, U>,

VCOMISD instruction

InstructionOpcodeCPUID
VCOMISD xmm1, xmm2/m64VEX.LIG.66.0F.WIG 2F /rAVX
VCOMISD xmm1, xmm2/m64{sae}EVEX.LIG.66.0F.W1 2F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcomish<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcomish<T, U>,

VCOMISH instruction

InstructionOpcodeCPUID
VCOMISH xmm1, xmm2/m16{sae}EVEX.LIG.MAP5.W0 2F /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcomiss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcomiss<T, U>,

VCOMISS instruction

InstructionOpcodeCPUID
VCOMISS xmm1, xmm2/m32VEX.LIG.0F.WIG 2F /rAVX
VCOMISS xmm1, xmm2/m32{sae}EVEX.LIG.0F.W0 2F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcompresspd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcompresspd<T, U>,

VCOMPRESSPD instruction

InstructionOpcodeCPUID
VCOMPRESSPD xmm1/m128 {k1}{z}, xmm2EVEX.128.66.0F38.W1 8A /rAVX512VL AVX512F
VCOMPRESSPD ymm1/m256 {k1}{z}, ymm2EVEX.256.66.0F38.W1 8A /rAVX512VL AVX512F
VCOMPRESSPD zmm1/m512 {k1}{z}, zmm2EVEX.512.66.0F38.W1 8A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcompressps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcompressps<T, U>,

VCOMPRESSPS instruction

InstructionOpcodeCPUID
VCOMPRESSPS xmm1/m128 {k1}{z}, xmm2EVEX.128.66.0F38.W0 8A /rAVX512VL AVX512F
VCOMPRESSPS ymm1/m256 {k1}{z}, ymm2EVEX.256.66.0F38.W0 8A /rAVX512VL AVX512F
VCOMPRESSPS zmm1/m512 {k1}{z}, zmm2EVEX.512.66.0F38.W0 8A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtdq2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtdq2pd<T, U>,

VCVTDQ2PD instruction

InstructionOpcodeCPUID
VCVTDQ2PD xmm1, xmm2/m64VEX.128.F3.0F.WIG E6 /rAVX
VCVTDQ2PD ymm1, xmm2/m128VEX.256.F3.0F.WIG E6 /rAVX
VCVTDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcstEVEX.128.F3.0F.W0 E6 /rAVX512VL AVX512F
VCVTDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcstEVEX.256.F3.0F.W0 E6 /rAVX512VL AVX512F
VCVTDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{er}EVEX.512.F3.0F.W0 E6 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtdq2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtdq2ph<T, U>,

VCVTDQ2PH instruction

InstructionOpcodeCPUID
VCVTDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.MAP5.W0 5B /rAVX512VL AVX512-FP16
VCVTDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.MAP5.W0 5B /rAVX512VL AVX512-FP16
VCVTDQ2PH ymm1 {k1}{z}, zmm2/m512/m32bcst{er}EVEX.512.MAP5.W0 5B /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtdq2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtdq2phx<T, U>,

VCVTDQ2PHX instruction

InstructionOpcodeCPUID
VCVTDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.MAP5.W0 5B /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtdq2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtdq2phy<T, U>,

VCVTDQ2PHY instruction

InstructionOpcodeCPUID
VCVTDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.MAP5.W0 5B /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtdq2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtdq2ps<T, U>,

VCVTDQ2PS instruction

InstructionOpcodeCPUID
VCVTDQ2PS xmm1, xmm2/m128VEX.128.0F.WIG 5B /rAVX
VCVTDQ2PS ymm1, ymm2/m256VEX.256.0F.WIG 5B /rAVX
VCVTDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.0F.W0 5B /rAVX512VL AVX512F
VCVTDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.0F.W0 5B /rAVX512VL AVX512F
VCVTDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}EVEX.512.0F.W0 5B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtne2ps2bf16<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtne2ps2bf16<T, U, V>,

VCVTNE2PS2BF16 instruction

InstructionOpcodeCPUID
VCVTNE2PS2BF16 xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.F2.0F38.W0 72 /rAVX512VL AVX512_BF16
VCVTNE2PS2BF16 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.F2.0F38.W0 72 /rAVX512VL AVX512_BF16
VCVTNE2PS2BF16 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.F2.0F38.W0 72 /rAVX512F 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
Source

pub fn vcvtneebf162ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtneebf162ps<T, U>,

VCVTNEEBF162PS instruction

InstructionOpcodeCPUID
VCVTNEEBF162PS xmm1, m128VEX.128.F3.0F38.W0 B0 !(11):rrr:bbbAVX-NE-CONVERT
VCVTNEEBF162PS ymm1, m256VEX.256.F3.0F38.W0 B0 !(11):rrr:bbbAVX-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
Source

pub fn vcvtneeph2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtneeph2ps<T, U>,

VCVTNEEPH2PS instruction

InstructionOpcodeCPUID
VCVTNEEPH2PS xmm1, m128VEX.128.66.0F38.W0 B0 !(11):rrr:bbbAVX-NE-CONVERT
VCVTNEEPH2PS ymm1, m256VEX.256.66.0F38.W0 B0 !(11):rrr:bbbAVX-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
Source

pub fn vcvtneobf162ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtneobf162ps<T, U>,

VCVTNEOBF162PS instruction

InstructionOpcodeCPUID
VCVTNEOBF162PS xmm1, m128VEX.128.F2.0F38.W0 B0 !(11):rrr:bbbAVX-NE-CONVERT
VCVTNEOBF162PS ymm1, m256VEX.256.F2.0F38.W0 B0 !(11):rrr:bbbAVX-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
Source

pub fn vcvtneoph2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtneoph2ps<T, U>,

VCVTNEOPH2PS instruction

InstructionOpcodeCPUID
VCVTNEOPH2PS xmm1, m128VEX.128.0F38.W0 B0 !(11):rrr:bbbAVX-NE-CONVERT
VCVTNEOPH2PS ymm1, m256VEX.256.0F38.W0 B0 !(11):rrr:bbbAVX-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
Source

pub fn vcvtneps2bf16<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtneps2bf16<T, U>,

VCVTNEPS2BF16 instruction

InstructionOpcodeCPUID
VCVTNEPS2BF16 xmm1, xmm2/m128VEX.128.F3.0F38.W0 72 /rAVX-NE-CONVERT
VCVTNEPS2BF16 xmm1, ymm2/m256VEX.256.F3.0F38.W0 72 /rAVX-NE-CONVERT
VCVTNEPS2BF16 xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.F3.0F38.W0 72 /rAVX512VL AVX512_BF16
VCVTNEPS2BF16 xmm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.F3.0F38.W0 72 /rAVX512VL AVX512_BF16
VCVTNEPS2BF16 ymm1 {k1}{z}, zmm2/m512/m32bcstEVEX.512.F3.0F38.W0 72 /rAVX512F 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
Source

pub fn vcvtneps2bf16x<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtneps2bf16x<T, U>,

VCVTNEPS2BF16X instruction

InstructionOpcodeCPUID
VCVTNEPS2BF16 xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.F3.0F38.W0 72 /rAVX512VL 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
Source

pub fn vcvtneps2bf16y<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtneps2bf16y<T, U>,

VCVTNEPS2BF16Y instruction

InstructionOpcodeCPUID
VCVTNEPS2BF16 xmm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.F3.0F38.W0 72 /rAVX512VL 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
Source

pub fn vcvtpd2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2dq<T, U>,

VCVTPD2DQ instruction

InstructionOpcodeCPUID
VCVTPD2DQ xmm1, xmm2/m128VEX.128.F2.0F.WIG E6 /rAVX
VCVTPD2DQ xmm1, ymm2/m256VEX.256.F2.0F.WIG E6 /rAVX
VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.F2.0F.W1 E6 /rAVX512VL AVX512F
VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.F2.0F.W1 E6 /rAVX512VL AVX512F
VCVTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.F2.0F.W1 E6 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2dqx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2dqx<T, U>,

VCVTPD2DQX instruction

InstructionOpcodeCPUID
VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.F2.0F.W1 E6 /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2dqy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2dqy<T, U>,

VCVTPD2DQY instruction

InstructionOpcodeCPUID
VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.F2.0F.W1 E6 /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2ph<T, U>,

VCVTPD2PH instruction

InstructionOpcodeCPUID
VCVTPD2PH xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.MAP5.W1 5A /rAVX512VL AVX512-FP16
VCVTPD2PH xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.MAP5.W1 5A /rAVX512VL AVX512-FP16
VCVTPD2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.66.MAP5.W1 5A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2phx<T, U>,

VCVTPD2PHX instruction

InstructionOpcodeCPUID
VCVTPD2PH xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.MAP5.W1 5A /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2phy<T, U>,

VCVTPD2PHY instruction

InstructionOpcodeCPUID
VCVTPD2PH xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.MAP5.W1 5A /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2phz<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2phz<T, U>,

VCVTPD2PHZ instruction

InstructionOpcodeCPUID
VCVTPD2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.66.MAP5.W1 5A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2ps<T, U>,

VCVTPD2PS instruction

InstructionOpcodeCPUID
VCVTPD2PS xmm1, xmm2/m128VEX.128.66.0F.WIG 5A /rAVX
VCVTPD2PS xmm1, ymm2/m256VEX.256.66.0F.WIG 5A /rAVX
VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F.W1 5A /rAVX512VL AVX512F
VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F.W1 5A /rAVX512VL AVX512F
VCVTPD2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.66.0F.W1 5A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2psx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2psx<T, U>,

VCVTPD2PSX instruction

InstructionOpcodeCPUID
VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F.W1 5A /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2psy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2psy<T, U>,

VCVTPD2PSY instruction

InstructionOpcodeCPUID
VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F.W1 5A /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2qq<T, U>,

VCVTPD2QQ instruction

InstructionOpcodeCPUID
VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F.W1 7B /rAVX512VL AVX512DQ
VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F.W1 7B /rAVX512VL AVX512DQ
VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.66.0F.W1 7B /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2udq<T, U>,

VCVTPD2UDQ instruction

InstructionOpcodeCPUID
VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.0F.W1 79 /rAVX512VL AVX512F
VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.0F.W1 79 /rAVX512VL AVX512F
VCVTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.0F.W1 79 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2udqx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2udqx<T, U>,

VCVTPD2UDQX instruction

InstructionOpcodeCPUID
VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.0F.W1 79 /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2udqy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2udqy<T, U>,

VCVTPD2UDQY instruction

InstructionOpcodeCPUID
VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.0F.W1 79 /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtpd2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtpd2uqq<T, U>,

VCVTPD2UQQ instruction

InstructionOpcodeCPUID
VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F.W1 79 /rAVX512VL AVX512DQ
VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F.W1 79 /rAVX512VL AVX512DQ
VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.66.0F.W1 79 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtph2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtph2dq<T, U>,

VCVTPH2DQ instruction

InstructionOpcodeCPUID
VCVTPH2DQ xmm1 {k1}{z}, xmm2/m64/m16bcstEVEX.128.66.MAP5.W0 5B /rAVX512VL AVX512-FP16
VCVTPH2DQ ymm1 {k1}{z}, xmm2/m128/m16bcstEVEX.256.66.MAP5.W0 5B /rAVX512VL AVX512-FP16
VCVTPH2DQ zmm1 {k1}{z}, ymm2/m256/m16bcst{er}EVEX.512.66.MAP5.W0 5B /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtph2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtph2pd<T, U>,

VCVTPH2PD instruction

InstructionOpcodeCPUID
VCVTPH2PD xmm1 {k1}{z}, xmm2/m32/m16bcstEVEX.128.MAP5.W0 5A /rAVX512VL AVX512-FP16
VCVTPH2PD ymm1 {k1}{z}, xmm2/m64/m16bcstEVEX.256.MAP5.W0 5A /rAVX512VL AVX512-FP16
VCVTPH2PD zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}EVEX.512.MAP5.W0 5A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtph2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtph2ps<T, U>,

VCVTPH2PS instruction

InstructionOpcodeCPUID
VCVTPH2PS xmm1, xmm2/m64VEX.128.66.0F38.W0 13 /rF16C
VCVTPH2PS ymm1, xmm2/m128VEX.256.66.0F38.W0 13 /rF16C
VCVTPH2PS xmm1 {k1}{z}, xmm2/m64EVEX.128.66.0F38.W0 13 /rAVX512VL AVX512F
VCVTPH2PS ymm1 {k1}{z}, xmm2/m128EVEX.256.66.0F38.W0 13 /rAVX512VL AVX512F
VCVTPH2PS zmm1 {k1}{z}, ymm2/m256{sae}EVEX.512.66.0F38.W0 13 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtph2psx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtph2psx<T, U>,

VCVTPH2PSX instruction

InstructionOpcodeCPUID
VCVTPH2PSX xmm1 {k1}{z}, xmm2/m64/m16bcstEVEX.128.66.MAP6.W0 13 /rAVX512VL AVX512-FP16
VCVTPH2PSX ymm1 {k1}{z}, xmm2/m128/m16bcstEVEX.256.66.MAP6.W0 13 /rAVX512VL AVX512-FP16
VCVTPH2PSX zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}EVEX.512.66.MAP6.W0 13 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtph2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtph2qq<T, U>,

VCVTPH2QQ instruction

InstructionOpcodeCPUID
VCVTPH2QQ xmm1 {k1}{z}, xmm2/m32/m16bcstEVEX.128.66.MAP5.W0 7B /rAVX512VL AVX512-FP16
VCVTPH2QQ ymm1 {k1}{z}, xmm2/m64/m16bcstEVEX.256.66.MAP5.W0 7B /rAVX512VL AVX512-FP16
VCVTPH2QQ zmm1 {k1}{z}, xmm2/m128/m16bcst{er}EVEX.512.66.MAP5.W0 7B /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtph2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtph2udq<T, U>,

VCVTPH2UDQ instruction

InstructionOpcodeCPUID
VCVTPH2UDQ xmm1 {k1}{z}, xmm2/m64/m16bcstEVEX.128.MAP5.W0 79 /rAVX512VL AVX512-FP16
VCVTPH2UDQ ymm1 {k1}{z}, xmm2/m128/m16bcstEVEX.256.MAP5.W0 79 /rAVX512VL AVX512-FP16
VCVTPH2UDQ zmm1 {k1}{z}, ymm2/m256/m16bcst{er}EVEX.512.MAP5.W0 79 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtph2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtph2uqq<T, U>,

VCVTPH2UQQ instruction

InstructionOpcodeCPUID
VCVTPH2UQQ xmm1 {k1}{z}, xmm2/m32/m16bcstEVEX.128.66.MAP5.W0 79 /rAVX512VL AVX512-FP16
VCVTPH2UQQ ymm1 {k1}{z}, xmm2/m64/m16bcstEVEX.256.66.MAP5.W0 79 /rAVX512VL AVX512-FP16
VCVTPH2UQQ zmm1 {k1}{z}, xmm2/m128/m16bcst{er}EVEX.512.66.MAP5.W0 79 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtph2uw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtph2uw<T, U>,

VCVTPH2UW instruction

InstructionOpcodeCPUID
VCVTPH2UW xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.MAP5.W0 7D /rAVX512VL AVX512-FP16
VCVTPH2UW ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.MAP5.W0 7D /rAVX512VL AVX512-FP16
VCVTPH2UW zmm1 {k1}{z}, zmm2/m512/m16bcst{er}EVEX.512.MAP5.W0 7D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtph2w<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtph2w<T, U>,

VCVTPH2W instruction

InstructionOpcodeCPUID
VCVTPH2W xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.66.MAP5.W0 7D /rAVX512VL AVX512-FP16
VCVTPH2W ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.66.MAP5.W0 7D /rAVX512VL AVX512-FP16
VCVTPH2W zmm1 {k1}{z}, zmm2/m512/m16bcst{er}EVEX.512.66.MAP5.W0 7D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtps2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtps2dq<T, U>,

VCVTPS2DQ instruction

InstructionOpcodeCPUID
VCVTPS2DQ xmm1, xmm2/m128VEX.128.66.0F.WIG 5B /rAVX
VCVTPS2DQ ymm1, ymm2/m256VEX.256.66.0F.WIG 5B /rAVX
VCVTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.0F.W0 5B /rAVX512VL AVX512F
VCVTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.0F.W0 5B /rAVX512VL AVX512F
VCVTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er}EVEX.512.66.0F.W0 5B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtps2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtps2pd<T, U>,

VCVTPS2PD instruction

InstructionOpcodeCPUID
VCVTPS2PD xmm1, xmm2/m64VEX.128.0F.WIG 5A /rAVX
VCVTPS2PD ymm1, xmm2/m128VEX.256.0F.WIG 5A /rAVX
VCVTPS2PD xmm1 {k1}{z}, xmm2/m64/m32bcstEVEX.128.0F.W0 5A /rAVX512VL AVX512F
VCVTPS2PD ymm1 {k1}{z}, xmm2/m128/m32bcstEVEX.256.0F.W0 5A /rAVX512VL AVX512F
VCVTPS2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}EVEX.512.0F.W0 5A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtps2ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtps2ph<T, U, V>,

VCVTPS2PH instruction

InstructionOpcodeCPUID
VCVTPS2PH xmm1/m64, xmm2, imm8VEX.128.66.0F3A.W0 1D /r ibF16C
VCVTPS2PH xmm1/m128, ymm2, imm8VEX.256.66.0F3A.W0 1D /r ibF16C
VCVTPS2PH xmm1/m64 {k1}{z}, xmm2, imm8EVEX.128.66.0F3A.W0 1D /r ibAVX512VL AVX512F
VCVTPS2PH xmm1/m128 {k1}{z}, ymm2, imm8EVEX.256.66.0F3A.W0 1D /r ibAVX512VL AVX512F
VCVTPS2PH ymm1/m256 {k1}{z}, zmm2{sae}, imm8EVEX.512.66.0F3A.W0 1D /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtps2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtps2phx<T, U>,

VCVTPS2PHX instruction

InstructionOpcodeCPUID
VCVTPS2PHX xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.MAP5.W0 1D /rAVX512VL AVX512-FP16
VCVTPS2PHX xmm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.MAP5.W0 1D /rAVX512VL AVX512-FP16
VCVTPS2PHX ymm1 {k1}{z}, zmm2/m512/m32bcst{er}EVEX.512.66.MAP5.W0 1D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtps2phxx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtps2phxx<T, U>,

VCVTPS2PHXX instruction

InstructionOpcodeCPUID
VCVTPS2PHX xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.MAP5.W0 1D /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtps2phxy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtps2phxy<T, U>,

VCVTPS2PHXY instruction

InstructionOpcodeCPUID
VCVTPS2PHX xmm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.MAP5.W0 1D /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtps2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtps2qq<T, U>,

VCVTPS2QQ instruction

InstructionOpcodeCPUID
VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcstEVEX.128.66.0F.W0 7B /rAVX512VL AVX512DQ
VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcstEVEX.256.66.0F.W0 7B /rAVX512VL AVX512DQ
VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er}EVEX.512.66.0F.W0 7B /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtps2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtps2udq<T, U>,

VCVTPS2UDQ instruction

InstructionOpcodeCPUID
VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.0F.W0 79 /rAVX512VL AVX512F
VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.0F.W0 79 /rAVX512VL AVX512F
VCVTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er}EVEX.512.0F.W0 79 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtps2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtps2uqq<T, U>,

VCVTPS2UQQ instruction

InstructionOpcodeCPUID
VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcstEVEX.128.66.0F.W0 79 /rAVX512VL AVX512DQ
VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcstEVEX.256.66.0F.W0 79 /rAVX512VL AVX512DQ
VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er}EVEX.512.66.0F.W0 79 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtqq2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtqq2pd<T, U>,

VCVTQQ2PD instruction

InstructionOpcodeCPUID
VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.F3.0F.W1 E6 /rAVX512VL AVX512DQ
VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.F3.0F.W1 E6 /rAVX512VL AVX512DQ
VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.F3.0F.W1 E6 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtqq2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtqq2ph<T, U>,

VCVTQQ2PH instruction

InstructionOpcodeCPUID
VCVTQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.MAP5.W1 5B /rAVX512VL AVX512-FP16
VCVTQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.MAP5.W1 5B /rAVX512VL AVX512-FP16
VCVTQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.MAP5.W1 5B /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtqq2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtqq2phx<T, U>,

VCVTQQ2PHX instruction

InstructionOpcodeCPUID
VCVTQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.MAP5.W1 5B /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtqq2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtqq2phy<T, U>,

VCVTQQ2PHY instruction

InstructionOpcodeCPUID
VCVTQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.MAP5.W1 5B /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtqq2phz<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtqq2phz<T, U>,

VCVTQQ2PHZ instruction

InstructionOpcodeCPUID
VCVTQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.MAP5.W1 5B /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtqq2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtqq2ps<T, U>,

VCVTQQ2PS instruction

InstructionOpcodeCPUID
VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.0F.W1 5B /rAVX512VL AVX512DQ
VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.0F.W1 5B /rAVX512VL AVX512DQ
VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.0F.W1 5B /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtqq2psx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtqq2psx<T, U>,

VCVTQQ2PSX instruction

InstructionOpcodeCPUID
VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.0F.W1 5B /rAVX512VL 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
Source

pub fn vcvtqq2psy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtqq2psy<T, U>,

VCVTQQ2PSY instruction

InstructionOpcodeCPUID
VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.0F.W1 5B /rAVX512VL 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
Source

pub fn vcvtsd2sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtsd2sh<T, U, V>,

VCVTSD2SH instruction

InstructionOpcodeCPUID
VCVTSD2SH xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.F2.MAP5.W1 5A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtsd2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtsd2si<T, U>,

VCVTSD2SI instruction

InstructionOpcodeCPUID
VCVTSD2SI r32, xmm1/m64VEX.LIG.F2.0F.W0 2D /rAVX
VCVTSD2SI r64, xmm1/m64VEX.LIG.F2.0F.W1 2D /rAVX
VCVTSD2SI r32, xmm1/m64{er}EVEX.LIG.F2.0F.W0 2D /rAVX512F
VCVTSD2SI r64, xmm1/m64{er}EVEX.LIG.F2.0F.W1 2D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtsd2ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtsd2ss<T, U, V>,

VCVTSD2SS instruction

InstructionOpcodeCPUID
VCVTSD2SS xmm1, xmm2, xmm3/m64VEX.LIG.F2.0F.WIG 5A /rAVX
VCVTSD2SS xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.F2.0F.W1 5A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtsd2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtsd2usi<T, U>,

VCVTSD2USI instruction

InstructionOpcodeCPUID
VCVTSD2USI r32, xmm1/m64{er}EVEX.LIG.F2.0F.W0 79 /rAVX512F
VCVTSD2USI r64, xmm1/m64{er}EVEX.LIG.F2.0F.W1 79 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtsh2sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtsh2sd<T, U, V>,

VCVTSH2SD instruction

InstructionOpcodeCPUID
VCVTSH2SD xmm1 {k1}{z}, xmm2, xmm3/m16{sae}EVEX.LIG.F3.MAP5.W0 5A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtsh2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtsh2si<T, U>,

VCVTSH2SI instruction

InstructionOpcodeCPUID
VCVTSH2SI r32, xmm1/m16{er}EVEX.LIG.F3.MAP5.W0 2D /rAVX512-FP16
VCVTSH2SI r64, xmm1/m16{er}EVEX.LIG.F3.MAP5.W1 2D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtsh2ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtsh2ss<T, U, V>,

VCVTSH2SS instruction

InstructionOpcodeCPUID
VCVTSH2SS xmm1 {k1}{z}, xmm2, xmm3/m16{sae}EVEX.LIG.MAP6.W0 13 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtsh2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtsh2usi<T, U>,

VCVTSH2USI instruction

InstructionOpcodeCPUID
VCVTSH2USI r32, xmm1/m16{er}EVEX.LIG.F3.MAP5.W0 79 /rAVX512-FP16
VCVTSH2USI r64, xmm1/m16{er}EVEX.LIG.F3.MAP5.W1 79 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtsi2sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtsi2sd<T, U, V>,

VCVTSI2SD instruction

InstructionOpcodeCPUID
VCVTSI2SD xmm1, xmm2, r/m32VEX.LIG.F2.0F.W0 2A /rAVX
VCVTSI2SD xmm1, xmm2, r/m64VEX.LIG.F2.0F.W1 2A /rAVX
VCVTSI2SD xmm1, xmm2, r/m32{er}EVEX.LIG.F2.0F.W0 2A /rAVX512F
VCVTSI2SD xmm1, xmm2, r/m64{er}EVEX.LIG.F2.0F.W1 2A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtsi2sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtsi2sh<T, U, V>,

VCVTSI2SH instruction

InstructionOpcodeCPUID
VCVTSI2SH xmm1, xmm2, r/m32{er}EVEX.LIG.F3.MAP5.W0 2A /rAVX512-FP16
VCVTSI2SH xmm1, xmm2, r/m64{er}EVEX.LIG.F3.MAP5.W1 2A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtsi2ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtsi2ss<T, U, V>,

VCVTSI2SS instruction

InstructionOpcodeCPUID
VCVTSI2SS xmm1, xmm2, r/m32VEX.LIG.F3.0F.W0 2A /rAVX
VCVTSI2SS xmm1, xmm2, r/m64VEX.LIG.F3.0F.W1 2A /rAVX
VCVTSI2SS xmm1, xmm2, r/m32{er}EVEX.LIG.F3.0F.W0 2A /rAVX512F
VCVTSI2SS xmm1, xmm2, r/m64{er}EVEX.LIG.F3.0F.W1 2A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtss2sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtss2sd<T, U, V>,

VCVTSS2SD instruction

InstructionOpcodeCPUID
VCVTSS2SD xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 5A /rAVX
VCVTSS2SD xmm1 {k1}{z}, xmm2, xmm3/m32{sae}EVEX.LIG.F3.0F.W0 5A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtss2sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtss2sh<T, U, V>,

VCVTSS2SH instruction

InstructionOpcodeCPUID
VCVTSS2SH xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.MAP5.W0 1D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtss2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtss2si<T, U>,

VCVTSS2SI instruction

InstructionOpcodeCPUID
VCVTSS2SI r32, xmm1/m32VEX.LIG.F3.0F.W0 2D /rAVX
VCVTSS2SI r64, xmm1/m32VEX.LIG.F3.0F.W1 2D /rAVX
VCVTSS2SI r32, xmm1/m32{er}EVEX.LIG.F3.0F.W0 2D /rAVX512F
VCVTSS2SI r64, xmm1/m32{er}EVEX.LIG.F3.0F.W1 2D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtss2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtss2usi<T, U>,

VCVTSS2USI instruction

InstructionOpcodeCPUID
VCVTSS2USI r32, xmm1/m32{er}EVEX.LIG.F3.0F.W0 79 /rAVX512F
VCVTSS2USI r64, xmm1/m32{er}EVEX.LIG.F3.0F.W1 79 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttpd2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttpd2dq<T, U>,

VCVTTPD2DQ instruction

InstructionOpcodeCPUID
VCVTTPD2DQ xmm1, xmm2/m128VEX.128.66.0F.WIG E6 /rAVX
VCVTTPD2DQ xmm1, ymm2/m256VEX.256.66.0F.WIG E6 /rAVX
VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F.W1 E6 /rAVX512VL AVX512F
VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F.W1 E6 /rAVX512VL AVX512F
VCVTTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae}EVEX.512.66.0F.W1 E6 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttpd2dqx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttpd2dqx<T, U>,

VCVTTPD2DQX instruction

InstructionOpcodeCPUID
VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F.W1 E6 /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttpd2dqy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttpd2dqy<T, U>,

VCVTTPD2DQY instruction

InstructionOpcodeCPUID
VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F.W1 E6 /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttpd2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttpd2qq<T, U>,

VCVTTPD2QQ instruction

InstructionOpcodeCPUID
VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F.W1 7A /rAVX512VL AVX512DQ
VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F.W1 7A /rAVX512VL AVX512DQ
VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}EVEX.512.66.0F.W1 7A /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttpd2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttpd2udq<T, U>,

VCVTTPD2UDQ instruction

InstructionOpcodeCPUID
VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.0F.W1 78 /rAVX512VL AVX512F
VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.0F.W1 78 /rAVX512VL AVX512F
VCVTTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae}EVEX.512.0F.W1 78 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttpd2udqx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttpd2udqx<T, U>,

VCVTTPD2UDQX instruction

InstructionOpcodeCPUID
VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.0F.W1 78 /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttpd2udqy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttpd2udqy<T, U>,

VCVTTPD2UDQY instruction

InstructionOpcodeCPUID
VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.0F.W1 78 /rAVX512VL AVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttpd2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttpd2uqq<T, U>,

VCVTTPD2UQQ instruction

InstructionOpcodeCPUID
VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F.W1 78 /rAVX512VL AVX512DQ
VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F.W1 78 /rAVX512VL AVX512DQ
VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}EVEX.512.66.0F.W1 78 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttph2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttph2dq<T, U>,

VCVTTPH2DQ instruction

InstructionOpcodeCPUID
VCVTTPH2DQ xmm1 {k1}{z}, xmm2/m64/m16bcstEVEX.128.F3.MAP5.W0 5B /rAVX512VL AVX512-FP16
VCVTTPH2DQ ymm1 {k1}{z}, xmm2/m128/m16bcstEVEX.256.F3.MAP5.W0 5B /rAVX512VL AVX512-FP16
VCVTTPH2DQ zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}EVEX.512.F3.MAP5.W0 5B /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttph2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttph2qq<T, U>,

VCVTTPH2QQ instruction

InstructionOpcodeCPUID
VCVTTPH2QQ xmm1 {k1}{z}, xmm2/m32/m16bcstEVEX.128.66.MAP5.W0 7A /rAVX512VL AVX512-FP16
VCVTTPH2QQ ymm1 {k1}{z}, xmm2/m64/m16bcstEVEX.256.66.MAP5.W0 7A /rAVX512VL AVX512-FP16
VCVTTPH2QQ zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}EVEX.512.66.MAP5.W0 7A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttph2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttph2udq<T, U>,

VCVTTPH2UDQ instruction

InstructionOpcodeCPUID
VCVTTPH2UDQ xmm1 {k1}{z}, xmm2/m64/m16bcstEVEX.128.MAP5.W0 78 /rAVX512VL AVX512-FP16
VCVTTPH2UDQ ymm1 {k1}{z}, xmm2/m128/m16bcstEVEX.256.MAP5.W0 78 /rAVX512VL AVX512-FP16
VCVTTPH2UDQ zmm1 {k1}{z}, ymm2/m256/m16bcst{sae}EVEX.512.MAP5.W0 78 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttph2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttph2uqq<T, U>,

VCVTTPH2UQQ instruction

InstructionOpcodeCPUID
VCVTTPH2UQQ xmm1 {k1}{z}, xmm2/m32/m16bcstEVEX.128.66.MAP5.W0 78 /rAVX512VL AVX512-FP16
VCVTTPH2UQQ ymm1 {k1}{z}, xmm2/m64/m16bcstEVEX.256.66.MAP5.W0 78 /rAVX512VL AVX512-FP16
VCVTTPH2UQQ zmm1 {k1}{z}, xmm2/m128/m16bcst{sae}EVEX.512.66.MAP5.W0 78 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttph2uw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttph2uw<T, U>,

VCVTTPH2UW instruction

InstructionOpcodeCPUID
VCVTTPH2UW xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.MAP5.W0 7C /rAVX512VL AVX512-FP16
VCVTTPH2UW ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.MAP5.W0 7C /rAVX512VL AVX512-FP16
VCVTTPH2UW zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}EVEX.512.MAP5.W0 7C /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttph2w<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttph2w<T, U>,

VCVTTPH2W instruction

InstructionOpcodeCPUID
VCVTTPH2W xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.66.MAP5.W0 7C /rAVX512VL AVX512-FP16
VCVTTPH2W ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.66.MAP5.W0 7C /rAVX512VL AVX512-FP16
VCVTTPH2W zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}EVEX.512.66.MAP5.W0 7C /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttps2dq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttps2dq<T, U>,

VCVTTPS2DQ instruction

InstructionOpcodeCPUID
VCVTTPS2DQ xmm1, xmm2/m128VEX.128.F3.0F.WIG 5B /rAVX
VCVTTPS2DQ ymm1, ymm2/m256VEX.256.F3.0F.WIG 5B /rAVX
VCVTTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.F3.0F.W0 5B /rAVX512VL AVX512F
VCVTTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.F3.0F.W0 5B /rAVX512VL AVX512F
VCVTTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}EVEX.512.F3.0F.W0 5B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttps2qq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttps2qq<T, U>,

VCVTTPS2QQ instruction

InstructionOpcodeCPUID
VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcstEVEX.128.66.0F.W0 7A /rAVX512VL AVX512DQ
VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcstEVEX.256.66.0F.W0 7A /rAVX512VL AVX512DQ
VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}EVEX.512.66.0F.W0 7A /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttps2udq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttps2udq<T, U>,

VCVTTPS2UDQ instruction

InstructionOpcodeCPUID
VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.0F.W0 78 /rAVX512VL AVX512F
VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.0F.W0 78 /rAVX512VL AVX512F
VCVTTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}EVEX.512.0F.W0 78 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttps2uqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttps2uqq<T, U>,

VCVTTPS2UQQ instruction

InstructionOpcodeCPUID
VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcstEVEX.128.66.0F.W0 78 /rAVX512VL AVX512DQ
VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcstEVEX.256.66.0F.W0 78 /rAVX512VL AVX512DQ
VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{sae}EVEX.512.66.0F.W0 78 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttsd2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttsd2si<T, U>,

VCVTTSD2SI instruction

InstructionOpcodeCPUID
VCVTTSD2SI r32, xmm1/m64VEX.LIG.F2.0F.W0 2C /rAVX
VCVTTSD2SI r64, xmm1/m64VEX.LIG.F2.0F.W1 2C /rAVX
VCVTTSD2SI r32, xmm1/m64{sae}EVEX.LIG.F2.0F.W0 2C /rAVX512F
VCVTTSD2SI r64, xmm1/m64{sae}EVEX.LIG.F2.0F.W1 2C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttsd2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttsd2usi<T, U>,

VCVTTSD2USI instruction

InstructionOpcodeCPUID
VCVTTSD2USI r32, xmm1/m64{sae}EVEX.LIG.F2.0F.W0 78 /rAVX512F
VCVTTSD2USI r64, xmm1/m64{sae}EVEX.LIG.F2.0F.W1 78 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttsh2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttsh2si<T, U>,

VCVTTSH2SI instruction

InstructionOpcodeCPUID
VCVTTSH2SI r32, xmm1/m16{sae}EVEX.LIG.F3.MAP5.W0 2C /rAVX512-FP16
VCVTTSH2SI r64, xmm1/m16{sae}EVEX.LIG.F3.MAP5.W1 2C /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttsh2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttsh2usi<T, U>,

VCVTTSH2USI instruction

InstructionOpcodeCPUID
VCVTTSH2USI r32, xmm1/m16{sae}EVEX.LIG.F3.MAP5.W0 78 /rAVX512-FP16
VCVTTSH2USI r64, xmm1/m16{sae}EVEX.LIG.F3.MAP5.W1 78 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttss2si<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttss2si<T, U>,

VCVTTSS2SI instruction

InstructionOpcodeCPUID
VCVTTSS2SI r32, xmm1/m32VEX.LIG.F3.0F.W0 2C /rAVX
VCVTTSS2SI r64, xmm1/m32VEX.LIG.F3.0F.W1 2C /rAVX
VCVTTSS2SI r32, xmm1/m32{sae}EVEX.LIG.F3.0F.W0 2C /rAVX512F
VCVTTSS2SI r64, xmm1/m32{sae}EVEX.LIG.F3.0F.W1 2C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvttss2usi<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvttss2usi<T, U>,

VCVTTSS2USI instruction

InstructionOpcodeCPUID
VCVTTSS2USI r32, xmm1/m32{sae}EVEX.LIG.F3.0F.W0 78 /rAVX512F
VCVTTSS2USI r64, xmm1/m32{sae}EVEX.LIG.F3.0F.W1 78 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtudq2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtudq2pd<T, U>,

VCVTUDQ2PD instruction

InstructionOpcodeCPUID
VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcstEVEX.128.F3.0F.W0 7A /rAVX512VL AVX512F
VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcstEVEX.256.F3.0F.W0 7A /rAVX512VL AVX512F
VCVTUDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{er}EVEX.512.F3.0F.W0 7A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtudq2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtudq2ph<T, U>,

VCVTUDQ2PH instruction

InstructionOpcodeCPUID
VCVTUDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.F2.MAP5.W0 7A /rAVX512VL AVX512-FP16
VCVTUDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.F2.MAP5.W0 7A /rAVX512VL AVX512-FP16
VCVTUDQ2PH ymm1 {k1}{z}, zmm2/m512/m32bcst{er}EVEX.512.F2.MAP5.W0 7A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtudq2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtudq2phx<T, U>,

VCVTUDQ2PHX instruction

InstructionOpcodeCPUID
VCVTUDQ2PH xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.F2.MAP5.W0 7A /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtudq2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtudq2phy<T, U>,

VCVTUDQ2PHY instruction

InstructionOpcodeCPUID
VCVTUDQ2PH xmm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.F2.MAP5.W0 7A /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtudq2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtudq2ps<T, U>,

VCVTUDQ2PS instruction

InstructionOpcodeCPUID
VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.F2.0F.W0 7A /rAVX512VL AVX512F
VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.F2.0F.W0 7A /rAVX512VL AVX512F
VCVTUDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}EVEX.512.F2.0F.W0 7A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtuqq2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtuqq2pd<T, U>,

VCVTUQQ2PD instruction

InstructionOpcodeCPUID
VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.F3.0F.W1 7A /rAVX512VL AVX512DQ
VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.F3.0F.W1 7A /rAVX512VL AVX512DQ
VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.F3.0F.W1 7A /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtuqq2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtuqq2ph<T, U>,

VCVTUQQ2PH instruction

InstructionOpcodeCPUID
VCVTUQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.F2.MAP5.W1 7A /rAVX512VL AVX512-FP16
VCVTUQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.F2.MAP5.W1 7A /rAVX512VL AVX512-FP16
VCVTUQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.F2.MAP5.W1 7A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtuqq2phx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtuqq2phx<T, U>,

VCVTUQQ2PHX instruction

InstructionOpcodeCPUID
VCVTUQQ2PH xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.F2.MAP5.W1 7A /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtuqq2phy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtuqq2phy<T, U>,

VCVTUQQ2PHY instruction

InstructionOpcodeCPUID
VCVTUQQ2PH xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.F2.MAP5.W1 7A /rAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtuqq2phz<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtuqq2phz<T, U>,

VCVTUQQ2PHZ instruction

InstructionOpcodeCPUID
VCVTUQQ2PH xmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.F2.MAP5.W1 7A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtuqq2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtuqq2ps<T, U>,

VCVTUQQ2PS instruction

InstructionOpcodeCPUID
VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.F2.0F.W1 7A /rAVX512VL AVX512DQ
VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.F2.0F.W1 7A /rAVX512VL AVX512DQ
VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.F2.0F.W1 7A /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtuqq2psx<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtuqq2psx<T, U>,

VCVTUQQ2PSX instruction

InstructionOpcodeCPUID
VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.F2.0F.W1 7A /rAVX512VL 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
Source

pub fn vcvtuqq2psy<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtuqq2psy<T, U>,

VCVTUQQ2PSY instruction

InstructionOpcodeCPUID
VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.F2.0F.W1 7A /rAVX512VL 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
Source

pub fn vcvtusi2sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtusi2sd<T, U, V>,

VCVTUSI2SD instruction

InstructionOpcodeCPUID
VCVTUSI2SD xmm1, xmm2, r/m32{er}EVEX.LIG.F2.0F.W0 7B /rAVX512F
VCVTUSI2SD xmm1, xmm2, r/m64{er}EVEX.LIG.F2.0F.W1 7B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtusi2sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtusi2sh<T, U, V>,

VCVTUSI2SH instruction

InstructionOpcodeCPUID
VCVTUSI2SH xmm1, xmm2, r/m32{er}EVEX.LIG.F3.MAP5.W0 7B /rAVX512-FP16
VCVTUSI2SH xmm1, xmm2, r/m64{er}EVEX.LIG.F3.MAP5.W1 7B /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtusi2ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVcvtusi2ss<T, U, V>,

VCVTUSI2SS instruction

InstructionOpcodeCPUID
VCVTUSI2SS xmm1, xmm2, r/m32{er}EVEX.LIG.F3.0F.W0 7B /rAVX512F
VCVTUSI2SS xmm1, xmm2, r/m64{er}EVEX.LIG.F3.0F.W1 7B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vcvtuw2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtuw2ph<T, U>,

VCVTUW2PH instruction

InstructionOpcodeCPUID
VCVTUW2PH xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.F2.MAP5.W0 7D /rAVX512VL AVX512-FP16
VCVTUW2PH ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.F2.MAP5.W0 7D /rAVX512VL AVX512-FP16
VCVTUW2PH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}EVEX.512.F2.MAP5.W0 7D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vcvtw2ph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVcvtw2ph<T, U>,

VCVTW2PH instruction

InstructionOpcodeCPUID
VCVTW2PH xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.F3.MAP5.W0 7D /rAVX512VL AVX512-FP16
VCVTW2PH ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.F3.MAP5.W0 7D /rAVX512VL AVX512-FP16
VCVTW2PH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}EVEX.512.F3.MAP5.W0 7D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 42 /r ibAVX512VL AVX512BW
VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 42 /r ibAVX512VL AVX512BW
VDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 42 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vdivpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVdivpd<T, U, V>,

VDIVPD instruction

InstructionOpcodeCPUID
VDIVPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 5E /rAVX
VDIVPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 5E /rAVX
VDIVPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 5E /rAVX512VL AVX512F
VDIVPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 5E /rAVX512VL AVX512F
VDIVPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F.W1 5E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vdivph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVdivph<T, U, V>,

VDIVPH instruction

InstructionOpcodeCPUID
VDIVPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.MAP5.W0 5E /rAVX512VL AVX512-FP16
VDIVPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.MAP5.W0 5E /rAVX512VL AVX512-FP16
VDIVPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.MAP5.W0 5E /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vdivps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVdivps<T, U, V>,

VDIVPS instruction

InstructionOpcodeCPUID
VDIVPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 5E /rAVX
VDIVPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 5E /rAVX
VDIVPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 5E /rAVX512VL AVX512F
VDIVPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 5E /rAVX512VL AVX512F
VDIVPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.0F.W0 5E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vdivsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVdivsd<T, U, V>,

VDIVSD instruction

InstructionOpcodeCPUID
VDIVSD xmm1, xmm2, xmm3/m64VEX.LIG.F2.0F.WIG 5E /rAVX
VDIVSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.F2.0F.W1 5E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vdivsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVdivsh<T, U, V>,

VDIVSH instruction

InstructionOpcodeCPUID
VDIVSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.F3.MAP5.W0 5E /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vdivss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVdivss<T, U, V>,

VDIVSS instruction

InstructionOpcodeCPUID
VDIVSS xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 5E /rAVX
VDIVSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.F3.0F.W0 5E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vdpbf16ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVdpbf16ps<T, U, V>,

VDPBF16PS instruction

InstructionOpcodeCPUID
VDPBF16PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.F3.0F38.W0 52 /rAVX512VL AVX512_BF16
VDPBF16PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.F3.0F38.W0 52 /rAVX512VL AVX512_BF16
VDPBF16PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.F3.0F38.W0 52 /rAVX512F 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
Source

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

InstructionOpcodeCPUID
VDPPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 41 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VDPPS xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 40 /r ibAVX
VDPPS ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 40 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn verr<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVerr<T>,

VERR instruction

InstructionOpcodeCPUID
VERR r/m16o16 0F 00 /4286+
VERR r32/m16o32 0F 00 /4386+
VERR r64/m16o64 0F 00 /4X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn verw<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVerw<T>,

VERW instruction

InstructionOpcodeCPUID
VERW r/m16o16 0F 00 /5286+
VERW r32/m16o32 0F 00 /5386+
VERW r64/m16o64 0F 00 /5X64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vexp2pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVexp2pd<T, U>,

VEXP2PD instruction

InstructionOpcodeCPUID
VEXP2PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}EVEX.512.66.0F38.W1 C8 /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vexp2ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVexp2ps<T, U>,

VEXP2PS instruction

InstructionOpcodeCPUID
VEXP2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}EVEX.512.66.0F38.W0 C8 /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vexpandpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVexpandpd<T, U>,

VEXPANDPD instruction

InstructionOpcodeCPUID
VEXPANDPD xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.W1 88 /rAVX512VL AVX512F
VEXPANDPD ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.W1 88 /rAVX512VL AVX512F
VEXPANDPD zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.W1 88 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vexpandps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVexpandps<T, U>,

VEXPANDPS instruction

InstructionOpcodeCPUID
VEXPANDPS xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.W0 88 /rAVX512VL AVX512F
VEXPANDPS ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.W0 88 /rAVX512VL AVX512F
VEXPANDPS zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.W0 88 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vextractf128<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextractf128<T, U, V>,

VEXTRACTF128 instruction

InstructionOpcodeCPUID
VEXTRACTF128 xmm1/m128, ymm2, imm8VEX.256.66.0F3A.W0 19 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextractf32x4<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextractf32x4<T, U, V>,

VEXTRACTF32X4 instruction

InstructionOpcodeCPUID
VEXTRACTF32X4 xmm1/m128 {k1}{z}, ymm2, imm8EVEX.256.66.0F3A.W0 19 /r ibAVX512VL AVX512F
VEXTRACTF32X4 xmm1/m128 {k1}{z}, zmm2, imm8EVEX.512.66.0F3A.W0 19 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextractf32x8<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextractf32x8<T, U, V>,

VEXTRACTF32X8 instruction

InstructionOpcodeCPUID
VEXTRACTF32X8 ymm1/m256 {k1}{z}, zmm2, imm8EVEX.512.66.0F3A.W0 1B /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextractf64x2<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextractf64x2<T, U, V>,

VEXTRACTF64X2 instruction

InstructionOpcodeCPUID
VEXTRACTF64X2 xmm1/m128 {k1}{z}, ymm2, imm8EVEX.256.66.0F3A.W1 19 /r ibAVX512VL AVX512DQ
VEXTRACTF64X2 xmm1/m128 {k1}{z}, zmm2, imm8EVEX.512.66.0F3A.W1 19 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextractf64x4<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextractf64x4<T, U, V>,

VEXTRACTF64X4 instruction

InstructionOpcodeCPUID
VEXTRACTF64X4 ymm1/m256 {k1}{z}, zmm2, imm8EVEX.512.66.0F3A.W1 1B /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextracti128<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextracti128<T, U, V>,

VEXTRACTI128 instruction

InstructionOpcodeCPUID
VEXTRACTI128 xmm1/m128, ymm2, imm8VEX.256.66.0F3A.W0 39 /r ibAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextracti32x4<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextracti32x4<T, U, V>,

VEXTRACTI32X4 instruction

InstructionOpcodeCPUID
VEXTRACTI32X4 xmm1/m128 {k1}{z}, ymm2, imm8EVEX.256.66.0F3A.W0 39 /r ibAVX512VL AVX512F
VEXTRACTI32X4 xmm1/m128 {k1}{z}, zmm2, imm8EVEX.512.66.0F3A.W0 39 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextracti32x8<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextracti32x8<T, U, V>,

VEXTRACTI32X8 instruction

InstructionOpcodeCPUID
VEXTRACTI32X8 ymm1/m256 {k1}{z}, zmm2, imm8EVEX.512.66.0F3A.W0 3B /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextracti64x2<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextracti64x2<T, U, V>,

VEXTRACTI64X2 instruction

InstructionOpcodeCPUID
VEXTRACTI64X2 xmm1/m128 {k1}{z}, ymm2, imm8EVEX.256.66.0F3A.W1 39 /r ibAVX512VL AVX512DQ
VEXTRACTI64X2 xmm1/m128 {k1}{z}, zmm2, imm8EVEX.512.66.0F3A.W1 39 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextracti64x4<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextracti64x4<T, U, V>,

VEXTRACTI64X4 instruction

InstructionOpcodeCPUID
VEXTRACTI64X4 ymm1/m256 {k1}{z}, zmm2, imm8EVEX.512.66.0F3A.W1 3B /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vextractps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVextractps<T, U, V>,

VEXTRACTPS instruction

InstructionOpcodeCPUID
VEXTRACTPS r/m32, xmm1, imm8VEX.128.66.0F3A.W0 17 /r ibAVX
VEXTRACTPS r64/m32, xmm1, imm8VEX.128.66.0F3A.W1 17 /r ibAVX
VEXTRACTPS r/m32, xmm1, imm8EVEX.128.66.0F3A.W0 17 /r ibAVX512F
VEXTRACTPS r64/m32, xmm1, imm8EVEX.128.66.0F3A.W1 17 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfcmaddcph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfcmaddcph<T, U, V>,

VFCMADDCPH instruction

InstructionOpcodeCPUID
VFCMADDCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.F2.MAP6.W0 56 /rAVX512VL AVX512-FP16
VFCMADDCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.F2.MAP6.W0 56 /rAVX512VL AVX512-FP16
VFCMADDCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.F2.MAP6.W0 56 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfcmaddcsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfcmaddcsh<T, U, V>,

VFCMADDCSH instruction

InstructionOpcodeCPUID
VFCMADDCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.F2.MAP6.W0 57 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfcmulcph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfcmulcph<T, U, V>,

VFCMULCPH instruction

InstructionOpcodeCPUID
VFCMULCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.F2.MAP6.W0 D6 /rAVX512VL AVX512-FP16
VFCMULCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.F2.MAP6.W0 D6 /rAVX512VL AVX512-FP16
VFCMULCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.F2.MAP6.W0 D6 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfcmulcsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfcmulcsh<T, U, V>,

VFCMULCSH instruction

InstructionOpcodeCPUID
VFCMULCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.F2.MAP6.W0 D7 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 54 /r ibAVX512VL AVX512F
VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 54 /r ibAVX512VL AVX512F
VFIXUPIMMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F3A.W1 54 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 54 /r ibAVX512VL AVX512F
VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 54 /r ibAVX512VL AVX512F
VFIXUPIMMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.66.0F3A.W0 54 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.66.0F3A.W1 55 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.66.0F3A.W0 55 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vfmadd132pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd132pd<T, U, V>,

VFMADD132PD instruction

InstructionOpcodeCPUID
VFMADD132PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 98 /rFMA
VFMADD132PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 98 /rFMA
VFMADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 98 /rAVX512VL AVX512F
VFMADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 98 /rAVX512VL AVX512F
VFMADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 98 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd132ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd132ph<T, U, V>,

VFMADD132PH instruction

InstructionOpcodeCPUID
VFMADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 98 /rAVX512VL AVX512-FP16
VFMADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 98 /rAVX512VL AVX512-FP16
VFMADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 98 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd132ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd132ps<T, U, V>,

VFMADD132PS instruction

InstructionOpcodeCPUID
VFMADD132PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 98 /rFMA
VFMADD132PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 98 /rFMA
VFMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 98 /rAVX512VL AVX512F
VFMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 98 /rAVX512VL AVX512F
VFMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 98 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd132sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd132sd<T, U, V>,

VFMADD132SD instruction

InstructionOpcodeCPUID
VFMADD132SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 99 /rFMA
VFMADD132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 99 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd132sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd132sh<T, U, V>,

VFMADD132SH instruction

InstructionOpcodeCPUID
VFMADD132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 99 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd132ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd132ss<T, U, V>,

VFMADD132SS instruction

InstructionOpcodeCPUID
VFMADD132SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 99 /rFMA
VFMADD132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 99 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd213pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd213pd<T, U, V>,

VFMADD213PD instruction

InstructionOpcodeCPUID
VFMADD213PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 A8 /rFMA
VFMADD213PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 A8 /rFMA
VFMADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 A8 /rAVX512VL AVX512F
VFMADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 A8 /rAVX512VL AVX512F
VFMADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 A8 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd213ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd213ph<T, U, V>,

VFMADD213PH instruction

InstructionOpcodeCPUID
VFMADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 A8 /rAVX512VL AVX512-FP16
VFMADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 A8 /rAVX512VL AVX512-FP16
VFMADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 A8 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd213ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd213ps<T, U, V>,

VFMADD213PS instruction

InstructionOpcodeCPUID
VFMADD213PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 A8 /rFMA
VFMADD213PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 A8 /rFMA
VFMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 A8 /rAVX512VL AVX512F
VFMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 A8 /rAVX512VL AVX512F
VFMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 A8 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd213sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd213sd<T, U, V>,

VFMADD213SD instruction

InstructionOpcodeCPUID
VFMADD213SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 A9 /rFMA
VFMADD213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 A9 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd213sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd213sh<T, U, V>,

VFMADD213SH instruction

InstructionOpcodeCPUID
VFMADD213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 A9 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd213ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd213ss<T, U, V>,

VFMADD213SS instruction

InstructionOpcodeCPUID
VFMADD213SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 A9 /rFMA
VFMADD213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 A9 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd231pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd231pd<T, U, V>,

VFMADD231PD instruction

InstructionOpcodeCPUID
VFMADD231PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 B8 /rFMA
VFMADD231PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 B8 /rFMA
VFMADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 B8 /rAVX512VL AVX512F
VFMADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 B8 /rAVX512VL AVX512F
VFMADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 B8 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd231ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd231ph<T, U, V>,

VFMADD231PH instruction

InstructionOpcodeCPUID
VFMADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 B8 /rAVX512VL AVX512-FP16
VFMADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 B8 /rAVX512VL AVX512-FP16
VFMADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 B8 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd231ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd231ps<T, U, V>,

VFMADD231PS instruction

InstructionOpcodeCPUID
VFMADD231PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 B8 /rFMA
VFMADD231PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 B8 /rFMA
VFMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 B8 /rAVX512VL AVX512F
VFMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 B8 /rAVX512VL AVX512F
VFMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 B8 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd231sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd231sd<T, U, V>,

VFMADD231SD instruction

InstructionOpcodeCPUID
VFMADD231SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 B9 /rFMA
VFMADD231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 B9 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd231sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd231sh<T, U, V>,

VFMADD231SH instruction

InstructionOpcodeCPUID
VFMADD231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 B9 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmadd231ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmadd231ss<T, U, V>,

VFMADD231SS instruction

InstructionOpcodeCPUID
VFMADD231SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 B9 /rFMA
VFMADD231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 B9 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddcph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddcph<T, U, V>,

VFMADDCPH instruction

InstructionOpcodeCPUID
VFMADDCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.F3.MAP6.W0 56 /rAVX512VL AVX512-FP16
VFMADDCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.F3.MAP6.W0 56 /rAVX512VL AVX512-FP16
VFMADDCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.F3.MAP6.W0 56 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddcsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddcsh<T, U, V>,

VFMADDCSH instruction

InstructionOpcodeCPUID
VFMADDCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.F3.MAP6.W0 57 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VFMADDPD xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 69 /r /is4FMA4
VFMADDPD ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 69 /r /is4FMA4
VFMADDPD xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 69 /r /is4FMA4
VFMADDPD ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 69 /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFMADDPS xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 68 /r /is4FMA4
VFMADDPS ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 68 /r /is4FMA4
VFMADDPS xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 68 /r /is4FMA4
VFMADDPS ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 68 /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFMADDSD xmm1, xmm2, xmm3/m64, xmm4VEX.LIG.66.0F3A.W0 6B /r /is4FMA4
VFMADDSD xmm1, xmm2, xmm3, xmm4/m64VEX.LIG.66.0F3A.W1 6B /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFMADDSS xmm1, xmm2, xmm3/m32, xmm4VEX.LIG.66.0F3A.W0 6A /r /is4FMA4
VFMADDSS xmm1, xmm2, xmm3, xmm4/m32VEX.LIG.66.0F3A.W1 6A /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vfmaddsub132pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddsub132pd<T, U, V>,

VFMADDSUB132PD instruction

InstructionOpcodeCPUID
VFMADDSUB132PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 96 /rFMA
VFMADDSUB132PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 96 /rFMA
VFMADDSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 96 /rAVX512VL AVX512F
VFMADDSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 96 /rAVX512VL AVX512F
VFMADDSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 96 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddsub132ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddsub132ph<T, U, V>,

VFMADDSUB132PH instruction

InstructionOpcodeCPUID
VFMADDSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 96 /rAVX512VL AVX512-FP16
VFMADDSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 96 /rAVX512VL AVX512-FP16
VFMADDSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 96 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddsub132ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddsub132ps<T, U, V>,

VFMADDSUB132PS instruction

InstructionOpcodeCPUID
VFMADDSUB132PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 96 /rFMA
VFMADDSUB132PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 96 /rFMA
VFMADDSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 96 /rAVX512VL AVX512F
VFMADDSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 96 /rAVX512VL AVX512F
VFMADDSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 96 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddsub213pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddsub213pd<T, U, V>,

VFMADDSUB213PD instruction

InstructionOpcodeCPUID
VFMADDSUB213PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 A6 /rFMA
VFMADDSUB213PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 A6 /rFMA
VFMADDSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 A6 /rAVX512VL AVX512F
VFMADDSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 A6 /rAVX512VL AVX512F
VFMADDSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 A6 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddsub213ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddsub213ph<T, U, V>,

VFMADDSUB213PH instruction

InstructionOpcodeCPUID
VFMADDSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 A6 /rAVX512VL AVX512-FP16
VFMADDSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 A6 /rAVX512VL AVX512-FP16
VFMADDSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 A6 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddsub213ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddsub213ps<T, U, V>,

VFMADDSUB213PS instruction

InstructionOpcodeCPUID
VFMADDSUB213PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 A6 /rFMA
VFMADDSUB213PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 A6 /rFMA
VFMADDSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 A6 /rAVX512VL AVX512F
VFMADDSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 A6 /rAVX512VL AVX512F
VFMADDSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 A6 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddsub231pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddsub231pd<T, U, V>,

VFMADDSUB231PD instruction

InstructionOpcodeCPUID
VFMADDSUB231PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 B6 /rFMA
VFMADDSUB231PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 B6 /rFMA
VFMADDSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 B6 /rAVX512VL AVX512F
VFMADDSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 B6 /rAVX512VL AVX512F
VFMADDSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 B6 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddsub231ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddsub231ph<T, U, V>,

VFMADDSUB231PH instruction

InstructionOpcodeCPUID
VFMADDSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 B6 /rAVX512VL AVX512-FP16
VFMADDSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 B6 /rAVX512VL AVX512-FP16
VFMADDSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 B6 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmaddsub231ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmaddsub231ps<T, U, V>,

VFMADDSUB231PS instruction

InstructionOpcodeCPUID
VFMADDSUB231PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 B6 /rFMA
VFMADDSUB231PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 B6 /rFMA
VFMADDSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 B6 /rAVX512VL AVX512F
VFMADDSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 B6 /rAVX512VL AVX512F
VFMADDSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 B6 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VFMADDSUBPD xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 5D /r /is4FMA4
VFMADDSUBPD ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 5D /r /is4FMA4
VFMADDSUBPD xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 5D /r /is4FMA4
VFMADDSUBPD ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 5D /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFMADDSUBPS xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 5C /r /is4FMA4
VFMADDSUBPS ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 5C /r /is4FMA4
VFMADDSUBPS xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 5C /r /is4FMA4
VFMADDSUBPS ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 5C /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vfmsub132pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub132pd<T, U, V>,

VFMSUB132PD instruction

InstructionOpcodeCPUID
VFMSUB132PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 9A /rFMA
VFMSUB132PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 9A /rFMA
VFMSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 9A /rAVX512VL AVX512F
VFMSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 9A /rAVX512VL AVX512F
VFMSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 9A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub132ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub132ph<T, U, V>,

VFMSUB132PH instruction

InstructionOpcodeCPUID
VFMSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 9A /rAVX512VL AVX512-FP16
VFMSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 9A /rAVX512VL AVX512-FP16
VFMSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 9A /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub132ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub132ps<T, U, V>,

VFMSUB132PS instruction

InstructionOpcodeCPUID
VFMSUB132PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 9A /rFMA
VFMSUB132PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 9A /rFMA
VFMSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 9A /rAVX512VL AVX512F
VFMSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 9A /rAVX512VL AVX512F
VFMSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 9A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub132sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub132sd<T, U, V>,

VFMSUB132SD instruction

InstructionOpcodeCPUID
VFMSUB132SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 9B /rFMA
VFMSUB132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 9B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub132sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub132sh<T, U, V>,

VFMSUB132SH instruction

InstructionOpcodeCPUID
VFMSUB132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 9B /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub132ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub132ss<T, U, V>,

VFMSUB132SS instruction

InstructionOpcodeCPUID
VFMSUB132SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 9B /rFMA
VFMSUB132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 9B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub213pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub213pd<T, U, V>,

VFMSUB213PD instruction

InstructionOpcodeCPUID
VFMSUB213PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 AA /rFMA
VFMSUB213PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 AA /rFMA
VFMSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 AA /rAVX512VL AVX512F
VFMSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 AA /rAVX512VL AVX512F
VFMSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 AA /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub213ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub213ph<T, U, V>,

VFMSUB213PH instruction

InstructionOpcodeCPUID
VFMSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 AA /rAVX512VL AVX512-FP16
VFMSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 AA /rAVX512VL AVX512-FP16
VFMSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 AA /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub213ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub213ps<T, U, V>,

VFMSUB213PS instruction

InstructionOpcodeCPUID
VFMSUB213PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 AA /rFMA
VFMSUB213PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 AA /rFMA
VFMSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 AA /rAVX512VL AVX512F
VFMSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 AA /rAVX512VL AVX512F
VFMSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 AA /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub213sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub213sd<T, U, V>,

VFMSUB213SD instruction

InstructionOpcodeCPUID
VFMSUB213SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 AB /rFMA
VFMSUB213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 AB /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub213sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub213sh<T, U, V>,

VFMSUB213SH instruction

InstructionOpcodeCPUID
VFMSUB213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 AB /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub213ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub213ss<T, U, V>,

VFMSUB213SS instruction

InstructionOpcodeCPUID
VFMSUB213SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 AB /rFMA
VFMSUB213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 AB /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub231pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub231pd<T, U, V>,

VFMSUB231PD instruction

InstructionOpcodeCPUID
VFMSUB231PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 BA /rFMA
VFMSUB231PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 BA /rFMA
VFMSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 BA /rAVX512VL AVX512F
VFMSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 BA /rAVX512VL AVX512F
VFMSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 BA /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub231ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub231ph<T, U, V>,

VFMSUB231PH instruction

InstructionOpcodeCPUID
VFMSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 BA /rAVX512VL AVX512-FP16
VFMSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 BA /rAVX512VL AVX512-FP16
VFMSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 BA /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub231ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub231ps<T, U, V>,

VFMSUB231PS instruction

InstructionOpcodeCPUID
VFMSUB231PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 BA /rFMA
VFMSUB231PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 BA /rFMA
VFMSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 BA /rAVX512VL AVX512F
VFMSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 BA /rAVX512VL AVX512F
VFMSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 BA /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub231sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub231sd<T, U, V>,

VFMSUB231SD instruction

InstructionOpcodeCPUID
VFMSUB231SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 BB /rFMA
VFMSUB231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 BB /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub231sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub231sh<T, U, V>,

VFMSUB231SH instruction

InstructionOpcodeCPUID
VFMSUB231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 BB /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsub231ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsub231ss<T, U, V>,

VFMSUB231SS instruction

InstructionOpcodeCPUID
VFMSUB231SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 BB /rFMA
VFMSUB231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 BB /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsubadd132pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsubadd132pd<T, U, V>,

VFMSUBADD132PD instruction

InstructionOpcodeCPUID
VFMSUBADD132PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 97 /rFMA
VFMSUBADD132PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 97 /rFMA
VFMSUBADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 97 /rAVX512VL AVX512F
VFMSUBADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 97 /rAVX512VL AVX512F
VFMSUBADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 97 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsubadd132ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsubadd132ph<T, U, V>,

VFMSUBADD132PH instruction

InstructionOpcodeCPUID
VFMSUBADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 97 /rAVX512VL AVX512-FP16
VFMSUBADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 97 /rAVX512VL AVX512-FP16
VFMSUBADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 97 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsubadd132ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsubadd132ps<T, U, V>,

VFMSUBADD132PS instruction

InstructionOpcodeCPUID
VFMSUBADD132PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 97 /rFMA
VFMSUBADD132PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 97 /rFMA
VFMSUBADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 97 /rAVX512VL AVX512F
VFMSUBADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 97 /rAVX512VL AVX512F
VFMSUBADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 97 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsubadd213pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsubadd213pd<T, U, V>,

VFMSUBADD213PD instruction

InstructionOpcodeCPUID
VFMSUBADD213PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 A7 /rFMA
VFMSUBADD213PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 A7 /rFMA
VFMSUBADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 A7 /rAVX512VL AVX512F
VFMSUBADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 A7 /rAVX512VL AVX512F
VFMSUBADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 A7 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsubadd213ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsubadd213ph<T, U, V>,

VFMSUBADD213PH instruction

InstructionOpcodeCPUID
VFMSUBADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 A7 /rAVX512VL AVX512-FP16
VFMSUBADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 A7 /rAVX512VL AVX512-FP16
VFMSUBADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 A7 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsubadd213ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsubadd213ps<T, U, V>,

VFMSUBADD213PS instruction

InstructionOpcodeCPUID
VFMSUBADD213PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 A7 /rFMA
VFMSUBADD213PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 A7 /rFMA
VFMSUBADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 A7 /rAVX512VL AVX512F
VFMSUBADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 A7 /rAVX512VL AVX512F
VFMSUBADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 A7 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsubadd231pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsubadd231pd<T, U, V>,

VFMSUBADD231PD instruction

InstructionOpcodeCPUID
VFMSUBADD231PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 B7 /rFMA
VFMSUBADD231PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 B7 /rFMA
VFMSUBADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 B7 /rAVX512VL AVX512F
VFMSUBADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 B7 /rAVX512VL AVX512F
VFMSUBADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 B7 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsubadd231ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsubadd231ph<T, U, V>,

VFMSUBADD231PH instruction

InstructionOpcodeCPUID
VFMSUBADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 B7 /rAVX512VL AVX512-FP16
VFMSUBADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 B7 /rAVX512VL AVX512-FP16
VFMSUBADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 B7 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmsubadd231ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmsubadd231ps<T, U, V>,

VFMSUBADD231PS instruction

InstructionOpcodeCPUID
VFMSUBADD231PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 B7 /rFMA
VFMSUBADD231PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 B7 /rFMA
VFMSUBADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 B7 /rAVX512VL AVX512F
VFMSUBADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 B7 /rAVX512VL AVX512F
VFMSUBADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 B7 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VFMSUBADDPD xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 5F /r /is4FMA4
VFMSUBADDPD ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 5F /r /is4FMA4
VFMSUBADDPD xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 5F /r /is4FMA4
VFMSUBADDPD ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 5F /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFMSUBADDPS xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 5E /r /is4FMA4
VFMSUBADDPS ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 5E /r /is4FMA4
VFMSUBADDPS xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 5E /r /is4FMA4
VFMSUBADDPS ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 5E /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFMSUBPD xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 6D /r /is4FMA4
VFMSUBPD ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 6D /r /is4FMA4
VFMSUBPD xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 6D /r /is4FMA4
VFMSUBPD ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 6D /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFMSUBPS xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 6C /r /is4FMA4
VFMSUBPS ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 6C /r /is4FMA4
VFMSUBPS xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 6C /r /is4FMA4
VFMSUBPS ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 6C /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFMSUBSD xmm1, xmm2, xmm3/m64, xmm4VEX.LIG.66.0F3A.W0 6F /r /is4FMA4
VFMSUBSD xmm1, xmm2, xmm3, xmm4/m64VEX.LIG.66.0F3A.W1 6F /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFMSUBSS xmm1, xmm2, xmm3/m32, xmm4VEX.LIG.66.0F3A.W0 6E /r /is4FMA4
VFMSUBSS xmm1, xmm2, xmm3, xmm4/m32VEX.LIG.66.0F3A.W1 6E /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vfmulcph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmulcph<T, U, V>,

VFMULCPH instruction

InstructionOpcodeCPUID
VFMULCPH xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.F3.MAP6.W0 D6 /rAVX512VL AVX512-FP16
VFMULCPH ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.F3.MAP6.W0 D6 /rAVX512VL AVX512-FP16
VFMULCPH zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.F3.MAP6.W0 D6 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfmulcsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfmulcsh<T, U, V>,

VFMULCSH instruction

InstructionOpcodeCPUID
VFMULCSH xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.F3.MAP6.W0 D7 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd132pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd132pd<T, U, V>,

VFNMADD132PD instruction

InstructionOpcodeCPUID
VFNMADD132PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 9C /rFMA
VFNMADD132PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 9C /rFMA
VFNMADD132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 9C /rAVX512VL AVX512F
VFNMADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 9C /rAVX512VL AVX512F
VFNMADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 9C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd132ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd132ph<T, U, V>,

VFNMADD132PH instruction

InstructionOpcodeCPUID
VFNMADD132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 9C /rAVX512VL AVX512-FP16
VFNMADD132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 9C /rAVX512VL AVX512-FP16
VFNMADD132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 9C /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd132ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd132ps<T, U, V>,

VFNMADD132PS instruction

InstructionOpcodeCPUID
VFNMADD132PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 9C /rFMA
VFNMADD132PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 9C /rFMA
VFNMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 9C /rAVX512VL AVX512F
VFNMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 9C /rAVX512VL AVX512F
VFNMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 9C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd132sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd132sd<T, U, V>,

VFNMADD132SD instruction

InstructionOpcodeCPUID
VFNMADD132SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 9D /rFMA
VFNMADD132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 9D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd132sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd132sh<T, U, V>,

VFNMADD132SH instruction

InstructionOpcodeCPUID
VFNMADD132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 9D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd132ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd132ss<T, U, V>,

VFNMADD132SS instruction

InstructionOpcodeCPUID
VFNMADD132SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 9D /rFMA
VFNMADD132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 9D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd213pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd213pd<T, U, V>,

VFNMADD213PD instruction

InstructionOpcodeCPUID
VFNMADD213PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 AC /rFMA
VFNMADD213PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 AC /rFMA
VFNMADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 AC /rAVX512VL AVX512F
VFNMADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 AC /rAVX512VL AVX512F
VFNMADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 AC /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd213ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd213ph<T, U, V>,

VFNMADD213PH instruction

InstructionOpcodeCPUID
VFNMADD213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 AC /rAVX512VL AVX512-FP16
VFNMADD213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 AC /rAVX512VL AVX512-FP16
VFNMADD213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 AC /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd213ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd213ps<T, U, V>,

VFNMADD213PS instruction

InstructionOpcodeCPUID
VFNMADD213PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 AC /rFMA
VFNMADD213PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 AC /rFMA
VFNMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 AC /rAVX512VL AVX512F
VFNMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 AC /rAVX512VL AVX512F
VFNMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 AC /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd213sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd213sd<T, U, V>,

VFNMADD213SD instruction

InstructionOpcodeCPUID
VFNMADD213SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 AD /rFMA
VFNMADD213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 AD /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd213sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd213sh<T, U, V>,

VFNMADD213SH instruction

InstructionOpcodeCPUID
VFNMADD213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 AD /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd213ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd213ss<T, U, V>,

VFNMADD213SS instruction

InstructionOpcodeCPUID
VFNMADD213SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 AD /rFMA
VFNMADD213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 AD /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd231pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd231pd<T, U, V>,

VFNMADD231PD instruction

InstructionOpcodeCPUID
VFNMADD231PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 BC /rFMA
VFNMADD231PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 BC /rFMA
VFNMADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 BC /rAVX512VL AVX512F
VFNMADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 BC /rAVX512VL AVX512F
VFNMADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 BC /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd231ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd231ph<T, U, V>,

VFNMADD231PH instruction

InstructionOpcodeCPUID
VFNMADD231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 BC /rAVX512VL AVX512-FP16
VFNMADD231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 BC /rAVX512VL AVX512-FP16
VFNMADD231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 BC /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd231ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd231ps<T, U, V>,

VFNMADD231PS instruction

InstructionOpcodeCPUID
VFNMADD231PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 BC /rFMA
VFNMADD231PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 BC /rFMA
VFNMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 BC /rAVX512VL AVX512F
VFNMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 BC /rAVX512VL AVX512F
VFNMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 BC /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd231sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd231sd<T, U, V>,

VFNMADD231SD instruction

InstructionOpcodeCPUID
VFNMADD231SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 BD /rFMA
VFNMADD231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 BD /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd231sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd231sh<T, U, V>,

VFNMADD231SH instruction

InstructionOpcodeCPUID
VFNMADD231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 BD /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmadd231ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmadd231ss<T, U, V>,

VFNMADD231SS instruction

InstructionOpcodeCPUID
VFNMADD231SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 BD /rFMA
VFNMADD231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 BD /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VFNMADDPD xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 79 /r /is4FMA4
VFNMADDPD ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 79 /r /is4FMA4
VFNMADDPD xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 79 /r /is4FMA4
VFNMADDPD ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 79 /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFNMADDPS xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 78 /r /is4FMA4
VFNMADDPS ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 78 /r /is4FMA4
VFNMADDPS xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 78 /r /is4FMA4
VFNMADDPS ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 78 /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFNMADDSD xmm1, xmm2, xmm3/m64, xmm4VEX.LIG.66.0F3A.W0 7B /r /is4FMA4
VFNMADDSD xmm1, xmm2, xmm3, xmm4/m64VEX.LIG.66.0F3A.W1 7B /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFNMADDSS xmm1, xmm2, xmm3/m32, xmm4VEX.LIG.66.0F3A.W0 7A /r /is4FMA4
VFNMADDSS xmm1, xmm2, xmm3, xmm4/m32VEX.LIG.66.0F3A.W1 7A /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vfnmsub132pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub132pd<T, U, V>,

VFNMSUB132PD instruction

InstructionOpcodeCPUID
VFNMSUB132PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 9E /rFMA
VFNMSUB132PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 9E /rFMA
VFNMSUB132PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 9E /rAVX512VL AVX512F
VFNMSUB132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 9E /rAVX512VL AVX512F
VFNMSUB132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 9E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub132ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub132ph<T, U, V>,

VFNMSUB132PH instruction

InstructionOpcodeCPUID
VFNMSUB132PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 9E /rAVX512VL AVX512-FP16
VFNMSUB132PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 9E /rAVX512VL AVX512-FP16
VFNMSUB132PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 9E /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub132ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub132ps<T, U, V>,

VFNMSUB132PS instruction

InstructionOpcodeCPUID
VFNMSUB132PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 9E /rFMA
VFNMSUB132PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 9E /rFMA
VFNMSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 9E /rAVX512VL AVX512F
VFNMSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 9E /rAVX512VL AVX512F
VFNMSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 9E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub132sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub132sd<T, U, V>,

VFNMSUB132SD instruction

InstructionOpcodeCPUID
VFNMSUB132SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 9F /rFMA
VFNMSUB132SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 9F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub132sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub132sh<T, U, V>,

VFNMSUB132SH instruction

InstructionOpcodeCPUID
VFNMSUB132SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 9F /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub132ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub132ss<T, U, V>,

VFNMSUB132SS instruction

InstructionOpcodeCPUID
VFNMSUB132SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 9F /rFMA
VFNMSUB132SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 9F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub213pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub213pd<T, U, V>,

VFNMSUB213PD instruction

InstructionOpcodeCPUID
VFNMSUB213PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 AE /rFMA
VFNMSUB213PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 AE /rFMA
VFNMSUB213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 AE /rAVX512VL AVX512F
VFNMSUB213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 AE /rAVX512VL AVX512F
VFNMSUB213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 AE /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub213ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub213ph<T, U, V>,

VFNMSUB213PH instruction

InstructionOpcodeCPUID
VFNMSUB213PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 AE /rAVX512VL AVX512-FP16
VFNMSUB213PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 AE /rAVX512VL AVX512-FP16
VFNMSUB213PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 AE /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub213ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub213ps<T, U, V>,

VFNMSUB213PS instruction

InstructionOpcodeCPUID
VFNMSUB213PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 AE /rFMA
VFNMSUB213PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 AE /rFMA
VFNMSUB213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 AE /rAVX512VL AVX512F
VFNMSUB213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 AE /rAVX512VL AVX512F
VFNMSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 AE /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub213sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub213sd<T, U, V>,

VFNMSUB213SD instruction

InstructionOpcodeCPUID
VFNMSUB213SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 AF /rFMA
VFNMSUB213SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 AF /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub213sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub213sh<T, U, V>,

VFNMSUB213SH instruction

InstructionOpcodeCPUID
VFNMSUB213SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 AF /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub213ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub213ss<T, U, V>,

VFNMSUB213SS instruction

InstructionOpcodeCPUID
VFNMSUB213SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 AF /rFMA
VFNMSUB213SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 AF /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub231pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub231pd<T, U, V>,

VFNMSUB231PD instruction

InstructionOpcodeCPUID
VFNMSUB231PD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 BE /rFMA
VFNMSUB231PD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 BE /rFMA
VFNMSUB231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 BE /rAVX512VL AVX512F
VFNMSUB231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 BE /rAVX512VL AVX512F
VFNMSUB231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 BE /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub231ph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub231ph<T, U, V>,

VFNMSUB231PH instruction

InstructionOpcodeCPUID
VFNMSUB231PH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 BE /rAVX512VL AVX512-FP16
VFNMSUB231PH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 BE /rAVX512VL AVX512-FP16
VFNMSUB231PH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 BE /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub231ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub231ps<T, U, V>,

VFNMSUB231PS instruction

InstructionOpcodeCPUID
VFNMSUB231PS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 BE /rFMA
VFNMSUB231PS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 BE /rFMA
VFNMSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 BE /rAVX512VL AVX512F
VFNMSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 BE /rAVX512VL AVX512F
VFNMSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 BE /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub231sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub231sd<T, U, V>,

VFNMSUB231SD instruction

InstructionOpcodeCPUID
VFNMSUB231SD xmm1, xmm2, xmm3/m64VEX.LIG.66.0F38.W1 BF /rFMA
VFNMSUB231SD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 BF /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub231sh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub231sh<T, U, V>,

VFNMSUB231SH instruction

InstructionOpcodeCPUID
VFNMSUB231SH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 BF /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfnmsub231ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfnmsub231ss<T, U, V>,

VFNMSUB231SS instruction

InstructionOpcodeCPUID
VFNMSUB231SS xmm1, xmm2, xmm3/m32VEX.LIG.66.0F38.W0 BF /rFMA
VFNMSUB231SS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 BF /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VFNMSUBPD xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 7D /r /is4FMA4
VFNMSUBPD ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 7D /r /is4FMA4
VFNMSUBPD xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 7D /r /is4FMA4
VFNMSUBPD ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 7D /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFNMSUBPS xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 7C /r /is4FMA4
VFNMSUBPS ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 7C /r /is4FMA4
VFNMSUBPS xmm1, xmm2, xmm3, xmm4/m128VEX.128.66.0F3A.W1 7C /r /is4FMA4
VFNMSUBPS ymm1, ymm2, ymm3, ymm4/m256VEX.256.66.0F3A.W1 7C /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFNMSUBSD xmm1, xmm2, xmm3/m64, xmm4VEX.LIG.66.0F3A.W0 7F /r /is4FMA4
VFNMSUBSD xmm1, xmm2, xmm3, xmm4/m64VEX.LIG.66.0F3A.W1 7F /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VFNMSUBSS xmm1, xmm2, xmm3/m32, xmm4VEX.LIG.66.0F3A.W0 7E /r /is4FMA4
VFNMSUBSS xmm1, xmm2, xmm3, xmm4/m32VEX.LIG.66.0F3A.W1 7E /r /is4FMA4
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vfpclasspd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclasspd<T, U, V>,

VFPCLASSPD instruction

InstructionOpcodeCPUID
VFPCLASSPD k2 {k1}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 66 /r ibAVX512VL AVX512DQ
VFPCLASSPD k2 {k1}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 66 /r ibAVX512VL AVX512DQ
VFPCLASSPD k2 {k1}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 66 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclasspdx<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclasspdx<T, U, V>,

VFPCLASSPDX instruction

InstructionOpcodeCPUID
VFPCLASSPD k2 {k1}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 66 /r ibAVX512VL 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
Source

pub fn vfpclasspdy<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclasspdy<T, U, V>,

VFPCLASSPDY instruction

InstructionOpcodeCPUID
VFPCLASSPD k2 {k1}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 66 /r ibAVX512VL 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
Source

pub fn vfpclasspdz<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclasspdz<T, U, V>,

VFPCLASSPDZ instruction

InstructionOpcodeCPUID
VFPCLASSPD k2 {k1}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 66 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclassph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclassph<T, U, V>,

VFPCLASSPH instruction

InstructionOpcodeCPUID
VFPCLASSPH k1 {k2}, xmm2/m128/m16bcst, imm8EVEX.128.0F3A.W0 66 /r ibAVX512VL AVX512-FP16
VFPCLASSPH k1 {k2}, ymm2/m256/m16bcst, imm8EVEX.256.0F3A.W0 66 /r ibAVX512VL AVX512-FP16
VFPCLASSPH k1 {k2}, zmm2/m512/m16bcst, imm8EVEX.512.0F3A.W0 66 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclassphx<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclassphx<T, U, V>,

VFPCLASSPHX instruction

InstructionOpcodeCPUID
VFPCLASSPH k1 {k2}, xmm2/m128/m16bcst, imm8EVEX.128.0F3A.W0 66 /r ibAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclassphy<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclassphy<T, U, V>,

VFPCLASSPHY instruction

InstructionOpcodeCPUID
VFPCLASSPH k1 {k2}, ymm2/m256/m16bcst, imm8EVEX.256.0F3A.W0 66 /r ibAVX512VL AVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclassphz<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclassphz<T, U, V>,

VFPCLASSPHZ instruction

InstructionOpcodeCPUID
VFPCLASSPH k1 {k2}, zmm2/m512/m16bcst, imm8EVEX.512.0F3A.W0 66 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclassps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclassps<T, U, V>,

VFPCLASSPS instruction

InstructionOpcodeCPUID
VFPCLASSPS k2 {k1}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 66 /r ibAVX512VL AVX512DQ
VFPCLASSPS k2 {k1}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 66 /r ibAVX512VL AVX512DQ
VFPCLASSPS k2 {k1}, zmm2/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 66 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclasspsx<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclasspsx<T, U, V>,

VFPCLASSPSX instruction

InstructionOpcodeCPUID
VFPCLASSPS k2 {k1}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 66 /r ibAVX512VL 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
Source

pub fn vfpclasspsy<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclasspsy<T, U, V>,

VFPCLASSPSY instruction

InstructionOpcodeCPUID
VFPCLASSPS k2 {k1}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 66 /r ibAVX512VL 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
Source

pub fn vfpclasspsz<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclasspsz<T, U, V>,

VFPCLASSPSZ instruction

InstructionOpcodeCPUID
VFPCLASSPS k2 {k1}, zmm2/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 66 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclasssd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclasssd<T, U, V>,

VFPCLASSSD instruction

InstructionOpcodeCPUID
VFPCLASSSD k2 {k1}, xmm2/m64, imm8EVEX.LIG.66.0F3A.W1 67 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclasssh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclasssh<T, U, V>,

VFPCLASSSH instruction

InstructionOpcodeCPUID
VFPCLASSSH k1 {k2}, xmm2/m16, imm8EVEX.LIG.0F3A.W0 67 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfpclassss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVfpclassss<T, U, V>,

VFPCLASSSS instruction

InstructionOpcodeCPUID
VFPCLASSSS k2 {k1}, xmm2/m32, imm8EVEX.LIG.66.0F3A.W0 67 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vfrczpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVfrczpd<T, U>,

VFRCZPD instruction

InstructionOpcodeCPUID
VFRCZPD xmm1, xmm2/m128XOP.128.X9.W0 81 /rXOP
VFRCZPD ymm1, ymm2/m256XOP.256.X9.W0 81 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vfrczps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVfrczps<T, U>,

VFRCZPS instruction

InstructionOpcodeCPUID
VFRCZPS xmm1, xmm2/m128XOP.128.X9.W0 80 /rXOP
VFRCZPS ymm1, ymm2/m256XOP.256.X9.W0 80 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vfrczsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVfrczsd<T, U>,

VFRCZSD instruction

InstructionOpcodeCPUID
VFRCZSD xmm1, xmm2/m64XOP.128.X9.W0 83 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vfrczss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVfrczss<T, U>,

VFRCZSS instruction

InstructionOpcodeCPUID
VFRCZSS xmm1, xmm2/m32XOP.128.X9.W0 82 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vgatherdpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVgatherdpd<T, U>,

VGATHERDPD instruction

InstructionOpcodeCPUID
VGATHERDPD xmm1 {k1}, vm32xEVEX.128.66.0F38.W1 92 /vsibAVX512VL AVX512F
VGATHERDPD ymm1 {k1}, vm32xEVEX.256.66.0F38.W1 92 /vsibAVX512VL AVX512F
VGATHERDPD zmm1 {k1}, vm32yEVEX.512.66.0F38.W1 92 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VGATHERDPD xmm1, vm32x, xmm2VEX.128.66.0F38.W1 92 /rAVX2
VGATHERDPD ymm1, vm32x, ymm2VEX.256.66.0F38.W1 92 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vgatherdps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVgatherdps<T, U>,

VGATHERDPS instruction

InstructionOpcodeCPUID
VGATHERDPS xmm1 {k1}, vm32xEVEX.128.66.0F38.W0 92 /vsibAVX512VL AVX512F
VGATHERDPS ymm1 {k1}, vm32yEVEX.256.66.0F38.W0 92 /vsibAVX512VL AVX512F
VGATHERDPS zmm1 {k1}, vm32zEVEX.512.66.0F38.W0 92 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VGATHERDPS xmm1, vm32x, xmm2VEX.128.66.0F38.W0 92 /rAVX2
VGATHERDPS ymm1, vm32y, ymm2VEX.256.66.0F38.W0 92 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vgatherpf0dpd<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVgatherpf0dpd<T>,

VGATHERPF0DPD instruction

InstructionOpcodeCPUID
VGATHERPF0DPD vm32y {k1}EVEX.512.66.0F38.W1 C6 /1 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vgatherpf0dps<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVgatherpf0dps<T>,

VGATHERPF0DPS instruction

InstructionOpcodeCPUID
VGATHERPF0DPS vm32z {k1}EVEX.512.66.0F38.W0 C6 /1 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vgatherpf0qpd<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVgatherpf0qpd<T>,

VGATHERPF0QPD instruction

InstructionOpcodeCPUID
VGATHERPF0QPD vm64z {k1}EVEX.512.66.0F38.W1 C7 /1 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vgatherpf0qps<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVgatherpf0qps<T>,

VGATHERPF0QPS instruction

InstructionOpcodeCPUID
VGATHERPF0QPS vm64z {k1}EVEX.512.66.0F38.W0 C7 /1 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vgatherpf1dpd<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVgatherpf1dpd<T>,

VGATHERPF1DPD instruction

InstructionOpcodeCPUID
VGATHERPF1DPD vm32y {k1}EVEX.512.66.0F38.W1 C6 /2 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vgatherpf1dps<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVgatherpf1dps<T>,

VGATHERPF1DPS instruction

InstructionOpcodeCPUID
VGATHERPF1DPS vm32z {k1}EVEX.512.66.0F38.W0 C6 /2 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vgatherpf1qpd<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVgatherpf1qpd<T>,

VGATHERPF1QPD instruction

InstructionOpcodeCPUID
VGATHERPF1QPD vm64z {k1}EVEX.512.66.0F38.W1 C7 /2 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vgatherpf1qps<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVgatherpf1qps<T>,

VGATHERPF1QPS instruction

InstructionOpcodeCPUID
VGATHERPF1QPS vm64z {k1}EVEX.512.66.0F38.W0 C7 /2 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vgatherqpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVgatherqpd<T, U>,

VGATHERQPD instruction

InstructionOpcodeCPUID
VGATHERQPD xmm1 {k1}, vm64xEVEX.128.66.0F38.W1 93 /vsibAVX512VL AVX512F
VGATHERQPD ymm1 {k1}, vm64yEVEX.256.66.0F38.W1 93 /vsibAVX512VL AVX512F
VGATHERQPD zmm1 {k1}, vm64zEVEX.512.66.0F38.W1 93 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VGATHERQPD xmm1, vm64x, xmm2VEX.128.66.0F38.W1 93 /rAVX2
VGATHERQPD ymm1, vm64y, ymm2VEX.256.66.0F38.W1 93 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vgatherqps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVgatherqps<T, U>,

VGATHERQPS instruction

InstructionOpcodeCPUID
VGATHERQPS xmm1 {k1}, vm64xEVEX.128.66.0F38.W0 93 /vsibAVX512VL AVX512F
VGATHERQPS xmm1 {k1}, vm64yEVEX.256.66.0F38.W0 93 /vsibAVX512VL AVX512F
VGATHERQPS ymm1 {k1}, vm64zEVEX.512.66.0F38.W0 93 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VGATHERQPS xmm1, vm64x, xmm2VEX.128.66.0F38.W0 93 /rAVX2
VGATHERQPS xmm1, vm64y, xmm2VEX.256.66.0F38.W0 93 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vgetexppd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVgetexppd<T, U>,

VGETEXPPD instruction

InstructionOpcodeCPUID
VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F38.W1 42 /rAVX512VL AVX512F
VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F38.W1 42 /rAVX512VL AVX512F
VGETEXPPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}EVEX.512.66.0F38.W1 42 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vgetexpph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVgetexpph<T, U>,

VGETEXPPH instruction

InstructionOpcodeCPUID
VGETEXPPH xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.66.MAP6.W0 42 /rAVX512VL AVX512-FP16
VGETEXPPH ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.66.MAP6.W0 42 /rAVX512VL AVX512-FP16
VGETEXPPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}EVEX.512.66.MAP6.W0 42 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vgetexpps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVgetexpps<T, U>,

VGETEXPPS instruction

InstructionOpcodeCPUID
VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.0F38.W0 42 /rAVX512VL AVX512F
VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.0F38.W0 42 /rAVX512VL AVX512F
VGETEXPPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}EVEX.512.66.0F38.W0 42 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vgetexpsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVgetexpsd<T, U, V>,

VGETEXPSD instruction

InstructionOpcodeCPUID
VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}EVEX.LIG.66.0F38.W1 43 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vgetexpsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVgetexpsh<T, U, V>,

VGETEXPSH instruction

InstructionOpcodeCPUID
VGETEXPSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}EVEX.LIG.66.MAP6.W0 43 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vgetexpss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVgetexpss<T, U, V>,

VGETEXPSS instruction

InstructionOpcodeCPUID
VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}EVEX.LIG.66.0F38.W0 43 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vgetmantpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVgetmantpd<T, U, V>,

VGETMANTPD instruction

InstructionOpcodeCPUID
VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 26 /r ibAVX512VL AVX512F
VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 26 /r ibAVX512VL AVX512F
VGETMANTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8EVEX.512.66.0F3A.W1 26 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vgetmantph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVgetmantph<T, U, V>,

VGETMANTPH instruction

InstructionOpcodeCPUID
VGETMANTPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8EVEX.128.0F3A.W0 26 /r ibAVX512VL AVX512-FP16
VGETMANTPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8EVEX.256.0F3A.W0 26 /r ibAVX512VL AVX512-FP16
VGETMANTPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 26 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vgetmantps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVgetmantps<T, U, V>,

VGETMANTPS instruction

InstructionOpcodeCPUID
VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 26 /r ibAVX512VL AVX512F
VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 26 /r ibAVX512VL AVX512F
VGETMANTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8EVEX.512.66.0F3A.W0 26 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.66.0F3A.W1 27 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VGETMANTSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.0F3A.W0 27 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.66.0F3A.W0 27 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VGF2P8AFFINEINVQB xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.W1 CF /r ibAVX GFNI
VGF2P8AFFINEINVQB ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.W1 CF /r ibAVX GFNI
VGF2P8AFFINEINVQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 CF /r ibAVX512VL GFNI
VGF2P8AFFINEINVQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 CF /r ibAVX512VL GFNI
VGF2P8AFFINEINVQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 CF /r ibAVX512F 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
Source

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

InstructionOpcodeCPUID
VGF2P8AFFINEQB xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.W1 CE /r ibAVX GFNI
VGF2P8AFFINEQB ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.W1 CE /r ibAVX GFNI
VGF2P8AFFINEQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 CE /r ibAVX512VL GFNI
VGF2P8AFFINEQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 CE /r ibAVX512VL GFNI
VGF2P8AFFINEQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 CE /r ibAVX512F 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
Source

pub fn vgf2p8mulb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVgf2p8mulb<T, U, V>,

VGF2P8MULB instruction

InstructionOpcodeCPUID
VGF2P8MULB xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 CF /rAVX GFNI
VGF2P8MULB ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 CF /rAVX GFNI
VGF2P8MULB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W0 CF /rAVX512VL GFNI
VGF2P8MULB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W0 CF /rAVX512VL GFNI
VGF2P8MULB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W0 CF /rAVX512F 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
Source

pub fn vhaddpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVhaddpd<T, U, V>,

VHADDPD instruction

InstructionOpcodeCPUID
VHADDPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 7C /rAVX
VHADDPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 7C /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vhaddps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVhaddps<T, U, V>,

VHADDPS instruction

InstructionOpcodeCPUID
VHADDPS xmm1, xmm2, xmm3/m128VEX.128.F2.0F.WIG 7C /rAVX
VHADDPS ymm1, ymm2, ymm3/m256VEX.256.F2.0F.WIG 7C /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vhsubpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVhsubpd<T, U, V>,

VHSUBPD instruction

InstructionOpcodeCPUID
VHSUBPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 7D /rAVX
VHSUBPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 7D /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vhsubps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVhsubps<T, U, V>,

VHSUBPS instruction

InstructionOpcodeCPUID
VHSUBPS xmm1, xmm2, xmm3/m128VEX.128.F2.0F.WIG 7D /rAVX
VHSUBPS ymm1, ymm2, ymm3/m256VEX.256.F2.0F.WIG 7D /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VINSERTF128 ymm1, ymm2, xmm3/m128, imm8VEX.256.66.0F3A.W0 18 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTF32X4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8EVEX.256.66.0F3A.W0 18 /r ibAVX512VL AVX512F
VINSERTF32X4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8EVEX.512.66.0F3A.W0 18 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTF32X8 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8EVEX.512.66.0F3A.W0 1A /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTF64X2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8EVEX.256.66.0F3A.W1 18 /r ibAVX512VL AVX512DQ
VINSERTF64X2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8EVEX.512.66.0F3A.W1 18 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTF64X4 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8EVEX.512.66.0F3A.W1 1A /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTI128 ymm1, ymm2, xmm3/m128, imm8VEX.256.66.0F3A.W0 38 /r ibAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTI32X4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8EVEX.256.66.0F3A.W0 38 /r ibAVX512VL AVX512F
VINSERTI32X4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8EVEX.512.66.0F3A.W0 38 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTI32X8 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8EVEX.512.66.0F3A.W0 3A /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTI64X2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8EVEX.256.66.0F3A.W1 38 /r ibAVX512VL AVX512DQ
VINSERTI64X2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8EVEX.512.66.0F3A.W1 38 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTI64X4 zmm1 {k1}{z}, zmm2, ymm3/m256, imm8EVEX.512.66.0F3A.W1 3A /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VINSERTPS xmm1, xmm2, xmm3/m32, imm8VEX.128.66.0F3A.WIG 21 /r ibAVX
VINSERTPS xmm1, xmm2, xmm3/m32, imm8EVEX.128.66.0F3A.W0 21 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vlddqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVlddqu<T, U>,

VLDDQU instruction

InstructionOpcodeCPUID
VLDDQU xmm1, m128VEX.128.F2.0F.WIG F0 /rAVX
VLDDQU ymm1, m256VEX.256.F2.0F.WIG F0 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vldmxcsr<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVldmxcsr<T>,

VLDMXCSR instruction

InstructionOpcodeCPUID
VLDMXCSR m32VEX.LZ.0F.WIG AE /2AVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vmaskmovdqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmaskmovdqu<T, U>,

VMASKMOVDQU instruction

InstructionOpcodeCPUID
VMASKMOVDQU xmm1, xmm2VEX.128.66.0F.WIG F7 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmaskmovpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmaskmovpd<T, U, V>,

VMASKMOVPD instruction

InstructionOpcodeCPUID
VMASKMOVPD xmm1, xmm2, m128VEX.128.66.0F38.W0 2D /rAVX
VMASKMOVPD ymm1, ymm2, m256VEX.256.66.0F38.W0 2D /rAVX
VMASKMOVPD m128, xmm1, xmm2VEX.128.66.0F38.W0 2F /rAVX
VMASKMOVPD m256, ymm1, ymm2VEX.256.66.0F38.W0 2F /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmaskmovps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmaskmovps<T, U, V>,

VMASKMOVPS instruction

InstructionOpcodeCPUID
VMASKMOVPS xmm1, xmm2, m128VEX.128.66.0F38.W0 2C /rAVX
VMASKMOVPS ymm1, ymm2, m256VEX.256.66.0F38.W0 2C /rAVX
VMASKMOVPS m128, xmm1, xmm2VEX.128.66.0F38.W0 2E /rAVX
VMASKMOVPS m256, ymm1, ymm2VEX.256.66.0F38.W0 2E /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmaxpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmaxpd<T, U, V>,

VMAXPD instruction

InstructionOpcodeCPUID
VMAXPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 5F /rAVX
VMAXPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 5F /rAVX
VMAXPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 5F /rAVX512VL AVX512F
VMAXPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 5F /rAVX512VL AVX512F
VMAXPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}EVEX.512.66.0F.W1 5F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmaxph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmaxph<T, U, V>,

VMAXPH instruction

InstructionOpcodeCPUID
VMAXPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.MAP5.W0 5F /rAVX512VL AVX512-FP16
VMAXPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.MAP5.W0 5F /rAVX512VL AVX512-FP16
VMAXPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{sae}EVEX.512.MAP5.W0 5F /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmaxps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmaxps<T, U, V>,

VMAXPS instruction

InstructionOpcodeCPUID
VMAXPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 5F /rAVX
VMAXPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 5F /rAVX
VMAXPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 5F /rAVX512VL AVX512F
VMAXPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 5F /rAVX512VL AVX512F
VMAXPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}EVEX.512.0F.W0 5F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmaxsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmaxsd<T, U, V>,

VMAXSD instruction

InstructionOpcodeCPUID
VMAXSD xmm1, xmm2, xmm3/m64VEX.LIG.F2.0F.WIG 5F /rAVX
VMAXSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}EVEX.LIG.F2.0F.W1 5F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmaxsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmaxsh<T, U, V>,

VMAXSH instruction

InstructionOpcodeCPUID
VMAXSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}EVEX.LIG.F3.MAP5.W0 5F /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmaxss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmaxss<T, U, V>,

VMAXSS instruction

InstructionOpcodeCPUID
VMAXSS xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 5F /rAVX
VMAXSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}EVEX.LIG.F3.0F.W0 5F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmcall(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmcall,

VMCALL instruction

InstructionOpcodeCPUID
VMCALLNP 0F 01 C1VMX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vmclear<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVmclear<T>,

VMCLEAR instruction

InstructionOpcodeCPUID
VMCLEAR m6466 0F C7 /6VMX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vmfunc(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmfunc,

VMFUNC instruction

InstructionOpcodeCPUID
VMFUNCNP 0F 01 D4VMX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vmgexit(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmgexit,

VMGEXIT instruction

InstructionOpcodeCPUID
VMGEXITF3 0F 01 D9SEV-ES
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vminpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVminpd<T, U, V>,

VMINPD instruction

InstructionOpcodeCPUID
VMINPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 5D /rAVX
VMINPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 5D /rAVX
VMINPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 5D /rAVX512VL AVX512F
VMINPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 5D /rAVX512VL AVX512F
VMINPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}EVEX.512.66.0F.W1 5D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vminph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVminph<T, U, V>,

VMINPH instruction

InstructionOpcodeCPUID
VMINPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.MAP5.W0 5D /rAVX512VL AVX512-FP16
VMINPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.MAP5.W0 5D /rAVX512VL AVX512-FP16
VMINPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{sae}EVEX.512.MAP5.W0 5D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vminps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVminps<T, U, V>,

VMINPS instruction

InstructionOpcodeCPUID
VMINPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 5D /rAVX
VMINPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 5D /rAVX
VMINPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 5D /rAVX512VL AVX512F
VMINPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 5D /rAVX512VL AVX512F
VMINPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}EVEX.512.0F.W0 5D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vminsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVminsd<T, U, V>,

VMINSD instruction

InstructionOpcodeCPUID
VMINSD xmm1, xmm2, xmm3/m64VEX.LIG.F2.0F.WIG 5D /rAVX
VMINSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}EVEX.LIG.F2.0F.W1 5D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vminsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVminsh<T, U, V>,

VMINSH instruction

InstructionOpcodeCPUID
VMINSH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}EVEX.LIG.F3.MAP5.W0 5D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vminss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVminss<T, U, V>,

VMINSS instruction

InstructionOpcodeCPUID
VMINSS xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 5D /rAVX
VMINSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}EVEX.LIG.F3.0F.W0 5D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmlaunch(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmlaunch,

VMLAUNCH instruction

InstructionOpcodeCPUID
VMLAUNCHNP 0F 01 C2VMX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vmload(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmload,

VMLOAD instruction

InstructionOpcodeCPUID
VMLOADa16 0F 01 DASVM
VMLOADa32 0F 01 DASVM
VMLOADa64 0F 01 DASVM
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vmmcall(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmmcall,

VMMCALL instruction

InstructionOpcodeCPUID
VMMCALL0F 01 D9SVM
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vmovapd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovapd<T, U>,

VMOVAPD instruction

InstructionOpcodeCPUID
VMOVAPD xmm1, xmm2/m128VEX.128.66.0F.WIG 28 /rAVX
VMOVAPD ymm1, ymm2/m256VEX.256.66.0F.WIG 28 /rAVX
VMOVAPD xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F.W1 28 /rAVX512VL AVX512F
VMOVAPD ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F.W1 28 /rAVX512VL AVX512F
VMOVAPD zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F.W1 28 /rAVX512F
VMOVAPD xmm2/m128, xmm1VEX.128.66.0F.WIG 29 /rAVX
VMOVAPD ymm2/m256, ymm1VEX.256.66.0F.WIG 29 /rAVX
VMOVAPD xmm2/m128 {k1}{z}, xmm1EVEX.128.66.0F.W1 29 /rAVX512VL AVX512F
VMOVAPD ymm2/m256 {k1}{z}, ymm1EVEX.256.66.0F.W1 29 /rAVX512VL AVX512F
VMOVAPD zmm2/m512 {k1}{z}, zmm1EVEX.512.66.0F.W1 29 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovaps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovaps<T, U>,

VMOVAPS instruction

InstructionOpcodeCPUID
VMOVAPS xmm1, xmm2/m128VEX.128.0F.WIG 28 /rAVX
VMOVAPS ymm1, ymm2/m256VEX.256.0F.WIG 28 /rAVX
VMOVAPS xmm1 {k1}{z}, xmm2/m128EVEX.128.0F.W0 28 /rAVX512VL AVX512F
VMOVAPS ymm1 {k1}{z}, ymm2/m256EVEX.256.0F.W0 28 /rAVX512VL AVX512F
VMOVAPS zmm1 {k1}{z}, zmm2/m512EVEX.512.0F.W0 28 /rAVX512F
VMOVAPS xmm2/m128, xmm1VEX.128.0F.WIG 29 /rAVX
VMOVAPS ymm2/m256, ymm1VEX.256.0F.WIG 29 /rAVX
VMOVAPS xmm2/m128 {k1}{z}, xmm1EVEX.128.0F.W0 29 /rAVX512VL AVX512F
VMOVAPS ymm2/m256 {k1}{z}, ymm1EVEX.256.0F.W0 29 /rAVX512VL AVX512F
VMOVAPS zmm2/m512 {k1}{z}, zmm1EVEX.512.0F.W0 29 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovd<T, U>,

VMOVD instruction

InstructionOpcodeCPUID
VMOVD xmm1, r/m32VEX.128.66.0F.W0 6E /rAVX
VMOVD xmm1, r/m32EVEX.128.66.0F.W0 6E /rAVX512F
VMOVD r/m32, xmm1VEX.128.66.0F.W0 7E /rAVX
VMOVD r/m32, xmm1EVEX.128.66.0F.W0 7E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovddup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovddup<T, U>,

VMOVDDUP instruction

InstructionOpcodeCPUID
VMOVDDUP xmm1, xmm2/m64VEX.128.F2.0F.WIG 12 /rAVX
VMOVDDUP ymm1, ymm2/m256VEX.256.F2.0F.WIG 12 /rAVX
VMOVDDUP xmm1 {k1}{z}, xmm2/m64EVEX.128.F2.0F.W1 12 /rAVX512VL AVX512F
VMOVDDUP ymm1 {k1}{z}, ymm2/m256EVEX.256.F2.0F.W1 12 /rAVX512VL AVX512F
VMOVDDUP zmm1 {k1}{z}, zmm2/m512EVEX.512.F2.0F.W1 12 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovdqa<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovdqa<T, U>,

VMOVDQA instruction

InstructionOpcodeCPUID
VMOVDQA xmm1, xmm2/m128VEX.128.66.0F.WIG 6F /rAVX
VMOVDQA ymm1, ymm2/m256VEX.256.66.0F.WIG 6F /rAVX
VMOVDQA xmm2/m128, xmm1VEX.128.66.0F.WIG 7F /rAVX
VMOVDQA ymm2/m256, ymm1VEX.256.66.0F.WIG 7F /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovdqa32<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovdqa32<T, U>,

VMOVDQA32 instruction

InstructionOpcodeCPUID
VMOVDQA32 xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F.W0 6F /rAVX512VL AVX512F
VMOVDQA32 ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F.W0 6F /rAVX512VL AVX512F
VMOVDQA32 zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F.W0 6F /rAVX512F
VMOVDQA32 xmm2/m128 {k1}{z}, xmm1EVEX.128.66.0F.W0 7F /rAVX512VL AVX512F
VMOVDQA32 ymm2/m256 {k1}{z}, ymm1EVEX.256.66.0F.W0 7F /rAVX512VL AVX512F
VMOVDQA32 zmm2/m512 {k1}{z}, zmm1EVEX.512.66.0F.W0 7F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovdqa64<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovdqa64<T, U>,

VMOVDQA64 instruction

InstructionOpcodeCPUID
VMOVDQA64 xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F.W1 6F /rAVX512VL AVX512F
VMOVDQA64 ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F.W1 6F /rAVX512VL AVX512F
VMOVDQA64 zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F.W1 6F /rAVX512F
VMOVDQA64 xmm2/m128 {k1}{z}, xmm1EVEX.128.66.0F.W1 7F /rAVX512VL AVX512F
VMOVDQA64 ymm2/m256 {k1}{z}, ymm1EVEX.256.66.0F.W1 7F /rAVX512VL AVX512F
VMOVDQA64 zmm2/m512 {k1}{z}, zmm1EVEX.512.66.0F.W1 7F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovdqu<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovdqu<T, U>,

VMOVDQU instruction

InstructionOpcodeCPUID
VMOVDQU xmm1, xmm2/m128VEX.128.F3.0F.WIG 6F /rAVX
VMOVDQU ymm1, ymm2/m256VEX.256.F3.0F.WIG 6F /rAVX
VMOVDQU xmm2/m128, xmm1VEX.128.F3.0F.WIG 7F /rAVX
VMOVDQU ymm2/m256, ymm1VEX.256.F3.0F.WIG 7F /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovdqu16<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovdqu16<T, U>,

VMOVDQU16 instruction

InstructionOpcodeCPUID
VMOVDQU16 xmm1 {k1}{z}, xmm2/m128EVEX.128.F2.0F.W1 6F /rAVX512VL AVX512BW
VMOVDQU16 ymm1 {k1}{z}, ymm2/m256EVEX.256.F2.0F.W1 6F /rAVX512VL AVX512BW
VMOVDQU16 zmm1 {k1}{z}, zmm2/m512EVEX.512.F2.0F.W1 6F /rAVX512BW
VMOVDQU16 xmm2/m128 {k1}{z}, xmm1EVEX.128.F2.0F.W1 7F /rAVX512VL AVX512BW
VMOVDQU16 ymm2/m256 {k1}{z}, ymm1EVEX.256.F2.0F.W1 7F /rAVX512VL AVX512BW
VMOVDQU16 zmm2/m512 {k1}{z}, zmm1EVEX.512.F2.0F.W1 7F /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovdqu32<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovdqu32<T, U>,

VMOVDQU32 instruction

InstructionOpcodeCPUID
VMOVDQU32 xmm1 {k1}{z}, xmm2/m128EVEX.128.F3.0F.W0 6F /rAVX512VL AVX512F
VMOVDQU32 ymm1 {k1}{z}, ymm2/m256EVEX.256.F3.0F.W0 6F /rAVX512VL AVX512F
VMOVDQU32 zmm1 {k1}{z}, zmm2/m512EVEX.512.F3.0F.W0 6F /rAVX512F
VMOVDQU32 xmm2/m128 {k1}{z}, xmm1EVEX.128.F3.0F.W0 7F /rAVX512VL AVX512F
VMOVDQU32 ymm2/m256 {k1}{z}, ymm1EVEX.256.F3.0F.W0 7F /rAVX512VL AVX512F
VMOVDQU32 zmm2/m512 {k1}{z}, zmm1EVEX.512.F3.0F.W0 7F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovdqu64<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovdqu64<T, U>,

VMOVDQU64 instruction

InstructionOpcodeCPUID
VMOVDQU64 xmm1 {k1}{z}, xmm2/m128EVEX.128.F3.0F.W1 6F /rAVX512VL AVX512F
VMOVDQU64 ymm1 {k1}{z}, ymm2/m256EVEX.256.F3.0F.W1 6F /rAVX512VL AVX512F
VMOVDQU64 zmm1 {k1}{z}, zmm2/m512EVEX.512.F3.0F.W1 6F /rAVX512F
VMOVDQU64 xmm2/m128 {k1}{z}, xmm1EVEX.128.F3.0F.W1 7F /rAVX512VL AVX512F
VMOVDQU64 ymm2/m256 {k1}{z}, ymm1EVEX.256.F3.0F.W1 7F /rAVX512VL AVX512F
VMOVDQU64 zmm2/m512 {k1}{z}, zmm1EVEX.512.F3.0F.W1 7F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovdqu8<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovdqu8<T, U>,

VMOVDQU8 instruction

InstructionOpcodeCPUID
VMOVDQU8 xmm1 {k1}{z}, xmm2/m128EVEX.128.F2.0F.W0 6F /rAVX512VL AVX512BW
VMOVDQU8 ymm1 {k1}{z}, ymm2/m256EVEX.256.F2.0F.W0 6F /rAVX512VL AVX512BW
VMOVDQU8 zmm1 {k1}{z}, zmm2/m512EVEX.512.F2.0F.W0 6F /rAVX512BW
VMOVDQU8 xmm2/m128 {k1}{z}, xmm1EVEX.128.F2.0F.W0 7F /rAVX512VL AVX512BW
VMOVDQU8 ymm2/m256 {k1}{z}, ymm1EVEX.256.F2.0F.W0 7F /rAVX512VL AVX512BW
VMOVDQU8 zmm2/m512 {k1}{z}, zmm1EVEX.512.F2.0F.W0 7F /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovhlps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmovhlps<T, U, V>,

VMOVHLPS instruction

InstructionOpcodeCPUID
VMOVHLPS xmm1, xmm2, xmm3VEX.128.0F.WIG 12 /rAVX
VMOVHLPS xmm1, xmm2, xmm3EVEX.128.0F.W0 12 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmovhpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovhpd<T, U>,

VMOVHPD instruction

InstructionOpcodeCPUID
VMOVHPD m64, xmm1VEX.128.66.0F.WIG 17 /rAVX
VMOVHPD m64, xmm1EVEX.128.66.0F.W1 17 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VMOVHPD xmm2, xmm1, m64VEX.128.66.0F.WIG 16 /rAVX
VMOVHPD xmm2, xmm1, m64EVEX.128.66.0F.W1 16 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmovhps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovhps<T, U>,

VMOVHPS instruction

InstructionOpcodeCPUID
VMOVHPS m64, xmm1VEX.128.0F.WIG 17 /rAVX
VMOVHPS m64, xmm1EVEX.128.0F.W0 17 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VMOVHPS xmm2, xmm1, m64VEX.128.0F.WIG 16 /rAVX
VMOVHPS xmm2, xmm1, m64EVEX.128.0F.W0 16 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmovlhps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmovlhps<T, U, V>,

VMOVLHPS instruction

InstructionOpcodeCPUID
VMOVLHPS xmm1, xmm2, xmm3VEX.128.0F.WIG 16 /rAVX
VMOVLHPS xmm1, xmm2, xmm3EVEX.128.0F.W0 16 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmovlpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovlpd<T, U>,

VMOVLPD instruction

InstructionOpcodeCPUID
VMOVLPD m64, xmm1VEX.128.66.0F.WIG 13 /rAVX
VMOVLPD m64, xmm1EVEX.128.66.0F.W1 13 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VMOVLPD xmm2, xmm1, m64VEX.128.66.0F.WIG 12 /rAVX
VMOVLPD xmm2, xmm1, m64EVEX.128.66.0F.W1 12 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmovlps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovlps<T, U>,

VMOVLPS instruction

InstructionOpcodeCPUID
VMOVLPS m64, xmm1VEX.128.0F.WIG 13 /rAVX
VMOVLPS m64, xmm1EVEX.128.0F.W0 13 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VMOVLPS xmm2, xmm1, m64VEX.128.0F.WIG 12 /rAVX
VMOVLPS xmm2, xmm1, m64EVEX.128.0F.W0 12 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmovmskpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovmskpd<T, U>,

VMOVMSKPD instruction

InstructionOpcodeCPUID
VMOVMSKPD r32, xmm2VEX.128.66.0F.W0 50 /rAVX
VMOVMSKPD r32, ymm2VEX.256.66.0F.W0 50 /rAVX
VMOVMSKPD r64, xmm2VEX.128.66.0F.W1 50 /rAVX
VMOVMSKPD r64, ymm2VEX.256.66.0F.W1 50 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovmskps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovmskps<T, U>,

VMOVMSKPS instruction

InstructionOpcodeCPUID
VMOVMSKPS r32, xmm2VEX.128.0F.W0 50 /rAVX
VMOVMSKPS r32, ymm2VEX.256.0F.W0 50 /rAVX
VMOVMSKPS r64, xmm2VEX.128.0F.W1 50 /rAVX
VMOVMSKPS r64, ymm2VEX.256.0F.W1 50 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovntdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovntdq<T, U>,

VMOVNTDQ instruction

InstructionOpcodeCPUID
VMOVNTDQ m128, xmm1VEX.128.66.0F.WIG E7 /rAVX
VMOVNTDQ m256, ymm1VEX.256.66.0F.WIG E7 /rAVX
VMOVNTDQ m128, xmm1EVEX.128.66.0F.W0 E7 /rAVX512VL AVX512F
VMOVNTDQ m256, ymm1EVEX.256.66.0F.W0 E7 /rAVX512VL AVX512F
VMOVNTDQ m512, zmm1EVEX.512.66.0F.W0 E7 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovntdqa<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovntdqa<T, U>,

VMOVNTDQA instruction

InstructionOpcodeCPUID
VMOVNTDQA xmm1, m128VEX.128.66.0F38.WIG 2A /rAVX
VMOVNTDQA ymm1, m256VEX.256.66.0F38.WIG 2A /rAVX2
VMOVNTDQA xmm1, m128EVEX.128.66.0F38.W0 2A /rAVX512VL AVX512F
VMOVNTDQA ymm1, m256EVEX.256.66.0F38.W0 2A /rAVX512VL AVX512F
VMOVNTDQA zmm1, m512EVEX.512.66.0F38.W0 2A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovntpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovntpd<T, U>,

VMOVNTPD instruction

InstructionOpcodeCPUID
VMOVNTPD m128, xmm1VEX.128.66.0F.WIG 2B /rAVX
VMOVNTPD m256, ymm1VEX.256.66.0F.WIG 2B /rAVX
VMOVNTPD m128, xmm1EVEX.128.66.0F.W1 2B /rAVX512VL AVX512F
VMOVNTPD m256, ymm1EVEX.256.66.0F.W1 2B /rAVX512VL AVX512F
VMOVNTPD m512, zmm1EVEX.512.66.0F.W1 2B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovntps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovntps<T, U>,

VMOVNTPS instruction

InstructionOpcodeCPUID
VMOVNTPS m128, xmm1VEX.128.0F.WIG 2B /rAVX
VMOVNTPS m256, ymm1VEX.256.0F.WIG 2B /rAVX
VMOVNTPS m128, xmm1EVEX.128.0F.W0 2B /rAVX512VL AVX512F
VMOVNTPS m256, ymm1EVEX.256.0F.W0 2B /rAVX512VL AVX512F
VMOVNTPS m512, zmm1EVEX.512.0F.W0 2B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovq<T, U>,

VMOVQ instruction

InstructionOpcodeCPUID
VMOVQ xmm1, r/m64VEX.128.66.0F.W1 6E /rAVX
VMOVQ xmm1, r/m64EVEX.128.66.0F.W1 6E /rAVX512F
VMOVQ r/m64, xmm1VEX.128.66.0F.W1 7E /rAVX
VMOVQ r/m64, xmm1EVEX.128.66.0F.W1 7E /rAVX512F
VMOVQ xmm1, xmm2/m64VEX.128.F3.0F.WIG 7E /rAVX
VMOVQ xmm1, xmm2/m64EVEX.128.F3.0F.W1 7E /rAVX512F
VMOVQ xmm1/m64, xmm2VEX.128.66.0F.WIG D6 /rAVX
VMOVQ xmm1/m64, xmm2EVEX.128.66.0F.W1 D6 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovsd<T, U>,

VMOVSD instruction

InstructionOpcodeCPUID
VMOVSD xmm1, m64VEX.LIG.F2.0F.WIG 10 /rAVX
VMOVSD xmm1 {k1}{z}, m64EVEX.LIG.F2.0F.W1 10 /rAVX512F
VMOVSD m64, xmm1VEX.LIG.F2.0F.WIG 11 /rAVX
VMOVSD m64 {k1}, xmm1EVEX.LIG.F2.0F.W1 11 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VMOVSD xmm1, xmm2, xmm3VEX.LIG.F2.0F.WIG 10 /rAVX
VMOVSD xmm1 {k1}{z}, xmm2, xmm3EVEX.LIG.F2.0F.W1 10 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmovsh<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovsh<T, U>,

VMOVSH instruction

InstructionOpcodeCPUID
VMOVSH xmm1 {k1}{z}, m16EVEX.LIG.F3.MAP5.W0 10 /rAVX512-FP16
VMOVSH m16 {k1}, xmm1EVEX.LIG.F3.MAP5.W0 11 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VMOVSH xmm1 {k1}{z}, xmm2, xmm3EVEX.LIG.F3.MAP5.W0 10 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmovshdup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovshdup<T, U>,

VMOVSHDUP instruction

InstructionOpcodeCPUID
VMOVSHDUP xmm1, xmm2/m128VEX.128.F3.0F.WIG 16 /rAVX
VMOVSHDUP ymm1, ymm2/m256VEX.256.F3.0F.WIG 16 /rAVX
VMOVSHDUP xmm1 {k1}{z}, xmm2/m128EVEX.128.F3.0F.W0 16 /rAVX512VL AVX512F
VMOVSHDUP ymm1 {k1}{z}, ymm2/m256EVEX.256.F3.0F.W0 16 /rAVX512VL AVX512F
VMOVSHDUP zmm1 {k1}{z}, zmm2/m512EVEX.512.F3.0F.W0 16 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovsldup<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovsldup<T, U>,

VMOVSLDUP instruction

InstructionOpcodeCPUID
VMOVSLDUP xmm1, xmm2/m128VEX.128.F3.0F.WIG 12 /rAVX
VMOVSLDUP ymm1, ymm2/m256VEX.256.F3.0F.WIG 12 /rAVX
VMOVSLDUP xmm1 {k1}{z}, xmm2/m128EVEX.128.F3.0F.W0 12 /rAVX512VL AVX512F
VMOVSLDUP ymm1 {k1}{z}, ymm2/m256EVEX.256.F3.0F.W0 12 /rAVX512VL AVX512F
VMOVSLDUP zmm1 {k1}{z}, zmm2/m512EVEX.512.F3.0F.W0 12 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovss<T, U>,

VMOVSS instruction

InstructionOpcodeCPUID
VMOVSS xmm1, m32VEX.LIG.F3.0F.WIG 10 /rAVX
VMOVSS xmm1 {k1}{z}, m32EVEX.LIG.F3.0F.W0 10 /rAVX512F
VMOVSS m32, xmm1VEX.LIG.F3.0F.WIG 11 /rAVX
VMOVSS m32 {k1}, xmm1EVEX.LIG.F3.0F.W0 11 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VMOVSS xmm1, xmm2, xmm3VEX.LIG.F3.0F.WIG 10 /rAVX
VMOVSS xmm1 {k1}{z}, xmm2, xmm3EVEX.LIG.F3.0F.W0 10 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmovupd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovupd<T, U>,

VMOVUPD instruction

InstructionOpcodeCPUID
VMOVUPD xmm1, xmm2/m128VEX.128.66.0F.WIG 10 /rAVX
VMOVUPD ymm1, ymm2/m256VEX.256.66.0F.WIG 10 /rAVX
VMOVUPD xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F.W1 10 /rAVX512VL AVX512F
VMOVUPD ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F.W1 10 /rAVX512VL AVX512F
VMOVUPD zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F.W1 10 /rAVX512F
VMOVUPD xmm2/m128, xmm1VEX.128.66.0F.WIG 11 /rAVX
VMOVUPD ymm2/m256, ymm1VEX.256.66.0F.WIG 11 /rAVX
VMOVUPD xmm2/m128 {k1}{z}, xmm1EVEX.128.66.0F.W1 11 /rAVX512VL AVX512F
VMOVUPD ymm2/m256 {k1}{z}, ymm1EVEX.256.66.0F.W1 11 /rAVX512VL AVX512F
VMOVUPD zmm2/m512 {k1}{z}, zmm1EVEX.512.66.0F.W1 11 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovups<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovups<T, U>,

VMOVUPS instruction

InstructionOpcodeCPUID
VMOVUPS xmm1, xmm2/m128VEX.128.0F.WIG 10 /rAVX
VMOVUPS ymm1, ymm2/m256VEX.256.0F.WIG 10 /rAVX
VMOVUPS xmm1 {k1}{z}, xmm2/m128EVEX.128.0F.W0 10 /rAVX512VL AVX512F
VMOVUPS ymm1 {k1}{z}, ymm2/m256EVEX.256.0F.W0 10 /rAVX512VL AVX512F
VMOVUPS zmm1 {k1}{z}, zmm2/m512EVEX.512.0F.W0 10 /rAVX512F
VMOVUPS xmm2/m128, xmm1VEX.128.0F.WIG 11 /rAVX
VMOVUPS ymm2/m256, ymm1VEX.256.0F.WIG 11 /rAVX
VMOVUPS xmm2/m128 {k1}{z}, xmm1EVEX.128.0F.W0 11 /rAVX512VL AVX512F
VMOVUPS ymm2/m256 {k1}{z}, ymm1EVEX.256.0F.W0 11 /rAVX512VL AVX512F
VMOVUPS zmm2/m512 {k1}{z}, zmm1EVEX.512.0F.W0 11 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmovw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmovw<T, U>,

VMOVW instruction

InstructionOpcodeCPUID
VMOVW xmm1, r32/m16EVEX.128.66.MAP5.W0 6E /rAVX512-FP16
VMOVW xmm1, r64/m16EVEX.128.66.MAP5.W1 6E /rAVX512-FP16
VMOVW r32/m16, xmm1EVEX.128.66.MAP5.W0 7E /rAVX512-FP16
VMOVW r64/m16, xmm1EVEX.128.66.MAP5.W1 7E /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VMPSADBW xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 42 /r ibAVX
VMPSADBW ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 42 /r ibAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vmptrld<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVmptrld<T>,

VMPTRLD instruction

InstructionOpcodeCPUID
VMPTRLD m64NP 0F C7 /6VMX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vmptrst<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVmptrst<T>,

VMPTRST instruction

InstructionOpcodeCPUID
VMPTRST m64NP 0F C7 /7VMX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vmread<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmread<T, U>,

VMREAD instruction

InstructionOpcodeCPUID
VMREAD r/m32, r32NP 0F 78 /rVMX
VMREAD r/m64, r64NP 0F 78 /rVMX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmresume(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmresume,

VMRESUME instruction

InstructionOpcodeCPUID
VMRESUMENP 0F 01 C3VMX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vmrun(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmrun,

VMRUN instruction

InstructionOpcodeCPUID
VMRUNa16 0F 01 D8SVM
VMRUNa32 0F 01 D8SVM
VMRUNa64 0F 01 D8SVM
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vmsave(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmsave,

VMSAVE instruction

InstructionOpcodeCPUID
VMSAVEa16 0F 01 DBSVM
VMSAVEa32 0F 01 DBSVM
VMSAVEa64 0F 01 DBSVM
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vmulpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmulpd<T, U, V>,

VMULPD instruction

InstructionOpcodeCPUID
VMULPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 59 /rAVX
VMULPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 59 /rAVX
VMULPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 59 /rAVX512VL AVX512F
VMULPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 59 /rAVX512VL AVX512F
VMULPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F.W1 59 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmulph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmulph<T, U, V>,

VMULPH instruction

InstructionOpcodeCPUID
VMULPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.MAP5.W0 59 /rAVX512VL AVX512-FP16
VMULPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.MAP5.W0 59 /rAVX512VL AVX512-FP16
VMULPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.MAP5.W0 59 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmulps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmulps<T, U, V>,

VMULPS instruction

InstructionOpcodeCPUID
VMULPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 59 /rAVX
VMULPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 59 /rAVX
VMULPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 59 /rAVX512VL AVX512F
VMULPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 59 /rAVX512VL AVX512F
VMULPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.0F.W0 59 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmulsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmulsd<T, U, V>,

VMULSD instruction

InstructionOpcodeCPUID
VMULSD xmm1, xmm2, xmm3/m64VEX.LIG.F2.0F.WIG 59 /rAVX
VMULSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.F2.0F.W1 59 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmulsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmulsh<T, U, V>,

VMULSH instruction

InstructionOpcodeCPUID
VMULSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.F3.MAP5.W0 59 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmulss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVmulss<T, U, V>,

VMULSS instruction

InstructionOpcodeCPUID
VMULSS xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 59 /rAVX
VMULSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.F3.0F.W0 59 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vmwrite<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVmwrite<T, U>,

VMWRITE instruction

InstructionOpcodeCPUID
VMWRITE r32, r/m32NP 0F 79 /rVMX
VMWRITE r64, r/m64NP 0F 79 /rVMX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vmxoff(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVmxoff,

VMXOFF instruction

InstructionOpcodeCPUID
VMXOFFNP 0F 01 C4VMX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vmxon<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVmxon<T>,

VMXON instruction

InstructionOpcodeCPUID
VMXON m64F3 0F C7 /6VMX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vorpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVorpd<T, U, V>,

VORPD instruction

InstructionOpcodeCPUID
VORPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 56 /rAVX
VORPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 56 /rAVX
VORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 56 /rAVX512VL AVX512DQ
VORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 56 /rAVX512VL AVX512DQ
VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 56 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vorps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVorps<T, U, V>,

VORPS instruction

InstructionOpcodeCPUID
VORPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 56 /rAVX
VORPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 56 /rAVX
VORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 56 /rAVX512VL AVX512DQ
VORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 56 /rAVX512VL AVX512DQ
VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.0F.W0 56 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vp2intersectd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVp2intersectd<T, U, V>,

VP2INTERSECTD instruction

InstructionOpcodeCPUID
VP2INTERSECTD k1+1, xmm2, xmm3/m128/m32bcstEVEX.128.F2.0F38.W0 68 /rAVX512VL AVX512_VP2INTERSECT
VP2INTERSECTD k1+1, ymm2, ymm3/m256/m32bcstEVEX.256.F2.0F38.W0 68 /rAVX512VL AVX512_VP2INTERSECT
VP2INTERSECTD k1+1, zmm2, zmm3/m512/m32bcstEVEX.512.F2.0F38.W0 68 /rAVX512F 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
Source

pub fn vp2intersectq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVp2intersectq<T, U, V>,

VP2INTERSECTQ instruction

InstructionOpcodeCPUID
VP2INTERSECTQ k1+1, xmm2, xmm3/m128/m64bcstEVEX.128.F2.0F38.W1 68 /rAVX512VL AVX512_VP2INTERSECT
VP2INTERSECTQ k1+1, ymm2, ymm3/m256/m64bcstEVEX.256.F2.0F38.W1 68 /rAVX512VL AVX512_VP2INTERSECT
VP2INTERSECTQ k1+1, zmm2, zmm3/m512/m64bcstEVEX.512.F2.0F38.W1 68 /rAVX512F 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
Source

pub fn vp4dpwssd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVp4dpwssd<T, U, V>,

VP4DPWSSD instruction

InstructionOpcodeCPUID
VP4DPWSSD zmm1 {k1}{z}, zmm2+3, m128EVEX.512.F2.0F38.W0 52 /rAVX512_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
Source

pub fn vp4dpwssds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVp4dpwssds<T, U, V>,

VP4DPWSSDS instruction

InstructionOpcodeCPUID
VP4DPWSSDS zmm1 {k1}{z}, zmm2+3, m128EVEX.512.F2.0F38.W0 53 /rAVX512_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
Source

pub fn vpabsb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpabsb<T, U>,

VPABSB instruction

InstructionOpcodeCPUID
VPABSB xmm1, xmm2/m128VEX.128.66.0F38.WIG 1C /rAVX
VPABSB ymm1, ymm2/m256VEX.256.66.0F38.WIG 1C /rAVX2
VPABSB xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.WIG 1C /rAVX512VL AVX512BW
VPABSB ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.WIG 1C /rAVX512VL AVX512BW
VPABSB zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.WIG 1C /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpabsd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpabsd<T, U>,

VPABSD instruction

InstructionOpcodeCPUID
VPABSD xmm1, xmm2/m128VEX.128.66.0F38.WIG 1E /rAVX
VPABSD ymm1, ymm2/m256VEX.256.66.0F38.WIG 1E /rAVX2
VPABSD xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.0F38.W0 1E /rAVX512VL AVX512F
VPABSD ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.0F38.W0 1E /rAVX512VL AVX512F
VPABSD zmm1 {k1}{z}, zmm2/m512/m32bcstEVEX.512.66.0F38.W0 1E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpabsq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpabsq<T, U>,

VPABSQ instruction

InstructionOpcodeCPUID
VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F38.W1 1F /rAVX512VL AVX512F
VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F38.W1 1F /rAVX512VL AVX512F
VPABSQ zmm1 {k1}{z}, zmm2/m512/m64bcstEVEX.512.66.0F38.W1 1F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpabsw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpabsw<T, U>,

VPABSW instruction

InstructionOpcodeCPUID
VPABSW xmm1, xmm2/m128VEX.128.66.0F38.WIG 1D /rAVX
VPABSW ymm1, ymm2/m256VEX.256.66.0F38.WIG 1D /rAVX2
VPABSW xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.WIG 1D /rAVX512VL AVX512BW
VPABSW ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.WIG 1D /rAVX512VL AVX512BW
VPABSW zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.WIG 1D /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpackssdw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpackssdw<T, U, V>,

VPACKSSDW instruction

InstructionOpcodeCPUID
VPACKSSDW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 6B /rAVX
VPACKSSDW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 6B /rAVX2
VPACKSSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 6B /rAVX512VL AVX512BW
VPACKSSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 6B /rAVX512VL AVX512BW
VPACKSSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 6B /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpacksswb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpacksswb<T, U, V>,

VPACKSSWB instruction

InstructionOpcodeCPUID
VPACKSSWB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 63 /rAVX
VPACKSSWB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 63 /rAVX2
VPACKSSWB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 63 /rAVX512VL AVX512BW
VPACKSSWB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 63 /rAVX512VL AVX512BW
VPACKSSWB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 63 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpackusdw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpackusdw<T, U, V>,

VPACKUSDW instruction

InstructionOpcodeCPUID
VPACKUSDW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 2B /rAVX
VPACKUSDW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 2B /rAVX2
VPACKUSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 2B /rAVX512VL AVX512BW
VPACKUSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 2B /rAVX512VL AVX512BW
VPACKUSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 2B /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpackuswb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpackuswb<T, U, V>,

VPACKUSWB instruction

InstructionOpcodeCPUID
VPACKUSWB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 67 /rAVX
VPACKUSWB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 67 /rAVX2
VPACKUSWB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 67 /rAVX512VL AVX512BW
VPACKUSWB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 67 /rAVX512VL AVX512BW
VPACKUSWB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 67 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpaddb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpaddb<T, U, V>,

VPADDB instruction

InstructionOpcodeCPUID
VPADDB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG FC /rAVX
VPADDB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG FC /rAVX2
VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG FC /rAVX512VL AVX512BW
VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG FC /rAVX512VL AVX512BW
VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG FC /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpaddd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpaddd<T, U, V>,

VPADDD instruction

InstructionOpcodeCPUID
VPADDD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG FE /rAVX
VPADDD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG FE /rAVX2
VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 FE /rAVX512VL AVX512F
VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 FE /rAVX512VL AVX512F
VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 FE /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpaddq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpaddq<T, U, V>,

VPADDQ instruction

InstructionOpcodeCPUID
VPADDQ xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG D4 /rAVX
VPADDQ ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG D4 /rAVX2
VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 D4 /rAVX512VL AVX512F
VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 D4 /rAVX512VL AVX512F
VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 D4 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpaddsb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpaddsb<T, U, V>,

VPADDSB instruction

InstructionOpcodeCPUID
VPADDSB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG EC /rAVX
VPADDSB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG EC /rAVX2
VPADDSB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG EC /rAVX512VL AVX512BW
VPADDSB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG EC /rAVX512VL AVX512BW
VPADDSB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG EC /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpaddsw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpaddsw<T, U, V>,

VPADDSW instruction

InstructionOpcodeCPUID
VPADDSW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG ED /rAVX
VPADDSW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG ED /rAVX2
VPADDSW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG ED /rAVX512VL AVX512BW
VPADDSW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG ED /rAVX512VL AVX512BW
VPADDSW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG ED /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpaddusb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpaddusb<T, U, V>,

VPADDUSB instruction

InstructionOpcodeCPUID
VPADDUSB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG DC /rAVX
VPADDUSB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG DC /rAVX2
VPADDUSB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG DC /rAVX512VL AVX512BW
VPADDUSB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG DC /rAVX512VL AVX512BW
VPADDUSB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG DC /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpaddusw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpaddusw<T, U, V>,

VPADDUSW instruction

InstructionOpcodeCPUID
VPADDUSW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG DD /rAVX
VPADDUSW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG DD /rAVX2
VPADDUSW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG DD /rAVX512VL AVX512BW
VPADDUSW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG DD /rAVX512VL AVX512BW
VPADDUSW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG DD /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpaddw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpaddw<T, U, V>,

VPADDW instruction

InstructionOpcodeCPUID
VPADDW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG FD /rAVX
VPADDW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG FD /rAVX2
VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG FD /rAVX512VL AVX512BW
VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG FD /rAVX512VL AVX512BW
VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG FD /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPALIGNR xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 0F /r ibAVX
VPALIGNR ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 0F /r ibAVX2
VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.WIG 0F /r ibAVX512VL AVX512BW
VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.WIG 0F /r ibAVX512VL AVX512BW
VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.WIG 0F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpand<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpand<T, U, V>,

VPAND instruction

InstructionOpcodeCPUID
VPAND xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG DB /rAVX
VPAND ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG DB /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpandd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpandd<T, U, V>,

VPANDD instruction

InstructionOpcodeCPUID
VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 DB /rAVX512VL AVX512F
VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 DB /rAVX512VL AVX512F
VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 DB /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpandn<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpandn<T, U, V>,

VPANDN instruction

InstructionOpcodeCPUID
VPANDN xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG DF /rAVX
VPANDN ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG DF /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpandnd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpandnd<T, U, V>,

VPANDND instruction

InstructionOpcodeCPUID
VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 DF /rAVX512VL AVX512F
VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 DF /rAVX512VL AVX512F
VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 DF /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpandnq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpandnq<T, U, V>,

VPANDNQ instruction

InstructionOpcodeCPUID
VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 DF /rAVX512VL AVX512F
VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 DF /rAVX512VL AVX512F
VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 DF /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpandq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpandq<T, U, V>,

VPANDQ instruction

InstructionOpcodeCPUID
VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 DB /rAVX512VL AVX512F
VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 DB /rAVX512VL AVX512F
VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 DB /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpavgb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpavgb<T, U, V>,

VPAVGB instruction

InstructionOpcodeCPUID
VPAVGB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG E0 /rAVX
VPAVGB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG E0 /rAVX2
VPAVGB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG E0 /rAVX512VL AVX512BW
VPAVGB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG E0 /rAVX512VL AVX512BW
VPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG E0 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpavgw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpavgw<T, U, V>,

VPAVGW instruction

InstructionOpcodeCPUID
VPAVGW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG E3 /rAVX
VPAVGW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG E3 /rAVX2
VPAVGW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG E3 /rAVX512VL AVX512BW
VPAVGW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG E3 /rAVX512VL AVX512BW
VPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG E3 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPBLENDD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.W0 02 /r ibAVX2
VPBLENDD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.W0 02 /r ibAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpblendmb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpblendmb<T, U, V>,

VPBLENDMB instruction

InstructionOpcodeCPUID
VPBLENDMB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W0 66 /rAVX512VL AVX512BW
VPBLENDMB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W0 66 /rAVX512VL AVX512BW
VPBLENDMB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W0 66 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpblendmd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpblendmd<T, U, V>,

VPBLENDMD instruction

InstructionOpcodeCPUID
VPBLENDMD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 64 /rAVX512VL AVX512F
VPBLENDMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 64 /rAVX512VL AVX512F
VPBLENDMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 64 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpblendmq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpblendmq<T, U, V>,

VPBLENDMQ instruction

InstructionOpcodeCPUID
VPBLENDMQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 64 /rAVX512VL AVX512F
VPBLENDMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 64 /rAVX512VL AVX512F
VPBLENDMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 64 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpblendmw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpblendmw<T, U, V>,

VPBLENDMW instruction

InstructionOpcodeCPUID
VPBLENDMW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 66 /rAVX512VL AVX512BW
VPBLENDMW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 66 /rAVX512VL AVX512BW
VPBLENDMW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 66 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4VEX.128.66.0F3A.W0 4C /r /is4AVX
VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4VEX.256.66.0F3A.W0 4C /r /is4AVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPBLENDW xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 0E /r ibAVX
VPBLENDW ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 0E /r ibAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpbroadcastb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpbroadcastb<T, U>,

VPBROADCASTB instruction

InstructionOpcodeCPUID
VPBROADCASTB xmm1, xmm2/m8VEX.128.66.0F38.W0 78 /rAVX2
VPBROADCASTB ymm1, xmm2/m8VEX.256.66.0F38.W0 78 /rAVX2
VPBROADCASTB xmm1 {k1}{z}, xmm2/m8EVEX.128.66.0F38.W0 78 /rAVX512VL AVX512BW
VPBROADCASTB ymm1 {k1}{z}, xmm2/m8EVEX.256.66.0F38.W0 78 /rAVX512VL AVX512BW
VPBROADCASTB zmm1 {k1}{z}, xmm2/m8EVEX.512.66.0F38.W0 78 /rAVX512BW
VPBROADCASTB xmm1 {k1}{z}, r32EVEX.128.66.0F38.W0 7A /rAVX512VL AVX512BW
VPBROADCASTB ymm1 {k1}{z}, r32EVEX.256.66.0F38.W0 7A /rAVX512VL AVX512BW
VPBROADCASTB zmm1 {k1}{z}, r32EVEX.512.66.0F38.W0 7A /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpbroadcastd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpbroadcastd<T, U>,

VPBROADCASTD instruction

InstructionOpcodeCPUID
VPBROADCASTD xmm1, xmm2/m32VEX.128.66.0F38.W0 58 /rAVX2
VPBROADCASTD ymm1, xmm2/m32VEX.256.66.0F38.W0 58 /rAVX2
VPBROADCASTD xmm1 {k1}{z}, xmm2/m32EVEX.128.66.0F38.W0 58 /rAVX512VL AVX512F
VPBROADCASTD ymm1 {k1}{z}, xmm2/m32EVEX.256.66.0F38.W0 58 /rAVX512VL AVX512F
VPBROADCASTD zmm1 {k1}{z}, xmm2/m32EVEX.512.66.0F38.W0 58 /rAVX512F
VPBROADCASTD xmm1 {k1}{z}, r32EVEX.128.66.0F38.W0 7C /rAVX512VL AVX512F
VPBROADCASTD ymm1 {k1}{z}, r32EVEX.256.66.0F38.W0 7C /rAVX512VL AVX512F
VPBROADCASTD zmm1 {k1}{z}, r32EVEX.512.66.0F38.W0 7C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpbroadcastmb2q<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpbroadcastmb2q<T, U>,

VPBROADCASTMB2Q instruction

InstructionOpcodeCPUID
VPBROADCASTMB2Q xmm1, k1EVEX.128.F3.0F38.W1 2A /rAVX512VL AVX512CD
VPBROADCASTMB2Q ymm1, k1EVEX.256.F3.0F38.W1 2A /rAVX512VL AVX512CD
VPBROADCASTMB2Q zmm1, k1EVEX.512.F3.0F38.W1 2A /rAVX512CD
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpbroadcastmw2d<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpbroadcastmw2d<T, U>,

VPBROADCASTMW2D instruction

InstructionOpcodeCPUID
VPBROADCASTMW2D xmm1, k1EVEX.128.F3.0F38.W0 3A /rAVX512VL AVX512CD
VPBROADCASTMW2D ymm1, k1EVEX.256.F3.0F38.W0 3A /rAVX512VL AVX512CD
VPBROADCASTMW2D zmm1, k1EVEX.512.F3.0F38.W0 3A /rAVX512CD
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpbroadcastq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpbroadcastq<T, U>,

VPBROADCASTQ instruction

InstructionOpcodeCPUID
VPBROADCASTQ xmm1, xmm2/m64VEX.128.66.0F38.W0 59 /rAVX2
VPBROADCASTQ ymm1, xmm2/m64VEX.256.66.0F38.W0 59 /rAVX2
VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64EVEX.128.66.0F38.W1 59 /rAVX512VL AVX512F
VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64EVEX.256.66.0F38.W1 59 /rAVX512VL AVX512F
VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64EVEX.512.66.0F38.W1 59 /rAVX512F
VPBROADCASTQ xmm1 {k1}{z}, r64EVEX.128.66.0F38.W1 7C /rAVX512VL AVX512F
VPBROADCASTQ ymm1 {k1}{z}, r64EVEX.256.66.0F38.W1 7C /rAVX512VL AVX512F
VPBROADCASTQ zmm1 {k1}{z}, r64EVEX.512.66.0F38.W1 7C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpbroadcastw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpbroadcastw<T, U>,

VPBROADCASTW instruction

InstructionOpcodeCPUID
VPBROADCASTW xmm1, xmm2/m16VEX.128.66.0F38.W0 79 /rAVX2
VPBROADCASTW ymm1, xmm2/m16VEX.256.66.0F38.W0 79 /rAVX2
VPBROADCASTW xmm1 {k1}{z}, xmm2/m16EVEX.128.66.0F38.W0 79 /rAVX512VL AVX512BW
VPBROADCASTW ymm1 {k1}{z}, xmm2/m16EVEX.256.66.0F38.W0 79 /rAVX512VL AVX512BW
VPBROADCASTW zmm1 {k1}{z}, xmm2/m16EVEX.512.66.0F38.W0 79 /rAVX512BW
VPBROADCASTW xmm1 {k1}{z}, r32EVEX.128.66.0F38.W0 7B /rAVX512VL AVX512BW
VPBROADCASTW ymm1 {k1}{z}, r32EVEX.256.66.0F38.W0 7B /rAVX512VL AVX512BW
VPBROADCASTW zmm1 {k1}{z}, r32EVEX.512.66.0F38.W0 7B /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpclmulhqhqdq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpclmulhqhqdq<T, U, V>,

VPCLMULHQHQDQ instruction

InstructionOpcodeCPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 44 /r ibPCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 44 /r ibVPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.WIG 44 /r ibAVX512F 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
Source

pub fn vpclmulhqlqdq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpclmulhqlqdq<T, U, V>,

VPCLMULHQLQDQ instruction

InstructionOpcodeCPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 44 /r ibPCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 44 /r ibVPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.WIG 44 /r ibAVX512F 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
Source

pub fn vpclmullqhqdq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpclmullqhqdq<T, U, V>,

VPCLMULLQHQDQ instruction

InstructionOpcodeCPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 44 /r ibPCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 44 /r ibVPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.WIG 44 /r ibAVX512F 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
Source

pub fn vpclmullqlqdq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpclmullqlqdq<T, U, V>,

VPCLMULLQLQDQ instruction

InstructionOpcodeCPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 44 /r ibPCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 44 /r ibVPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.WIG 44 /r ibAVX512F 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
Source

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

InstructionOpcodeCPUID
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.WIG 44 /r ibPCLMULQDQ AVX
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.WIG 44 /r ibVPCLMULQDQ
VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ ymm1, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.WIG 44 /r ibAVX512VL VPCLMULQDQ
VPCLMULQDQ zmm1, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.WIG 44 /r ibAVX512F 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
Source

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

InstructionOpcodeCPUID
VPCMOV xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 A2 /r /is4XOP
VPCMOV ymm1, ymm2, ymm3/m256, ymm4XOP.256.X8.W0 A2 /r /is4XOP
VPCMOV xmm1, xmm2, xmm3, xmm4/m128XOP.128.X8.W1 A2 /r /is4XOP
VPCMOV ymm1, ymm2, ymm3, ymm4/m256XOP.256.X8.W1 A2 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpcmpeqb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpeqb<T, U, V>,

VPCMPEQB instruction

InstructionOpcodeCPUID
VPCMPEQB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 74 /rAVX
VPCMPEQB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 74 /rAVX2
VPCMPEQB k1 {k2}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 74 /rAVX512VL AVX512BW
VPCMPEQB k1 {k2}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 74 /rAVX512VL AVX512BW
VPCMPEQB k1 {k2}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 74 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpeqd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpeqd<T, U, V>,

VPCMPEQD instruction

InstructionOpcodeCPUID
VPCMPEQD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 76 /rAVX
VPCMPEQD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 76 /rAVX2
VPCMPEQD k1 {k2}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 76 /rAVX512VL AVX512F
VPCMPEQD k1 {k2}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 76 /rAVX512VL AVX512F
VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 76 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpeqq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpeqq<T, U, V>,

VPCMPEQQ instruction

InstructionOpcodeCPUID
VPCMPEQQ xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 29 /rAVX
VPCMPEQQ ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 29 /rAVX2
VPCMPEQQ k1 {k2}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 29 /rAVX512VL AVX512F
VPCMPEQQ k1 {k2}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 29 /rAVX512VL AVX512F
VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 29 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpequb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpequb<T, U, V>,

VPCMPEQUB instruction

InstructionOpcodeCPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpequd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpequd<T, U, V>,

VPCMPEQUD instruction

InstructionOpcodeCPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpequq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpequq<T, U, V>,

VPCMPEQUQ instruction

InstructionOpcodeCPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpequw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpequw<T, U, V>,

VPCMPEQUW instruction

InstructionOpcodeCPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpeqw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpeqw<T, U, V>,

VPCMPEQW instruction

InstructionOpcodeCPUID
VPCMPEQW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 75 /rAVX
VPCMPEQW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 75 /rAVX2
VPCMPEQW k1 {k2}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 75 /rAVX512VL AVX512BW
VPCMPEQW k1 {k2}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 75 /rAVX512VL AVX512BW
VPCMPEQW k1 {k2}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 75 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpestri<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpestri<T, U, V>,

VPCMPESTRI instruction

InstructionOpcodeCPUID
VPCMPESTRI xmm1, xmm2/m128, imm8VEX.128.66.0F3A.W0 61 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpestri64<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpestri64<T, U, V>,

VPCMPESTRI64 instruction

InstructionOpcodeCPUID
VPCMPESTRI64 xmm1, xmm2/m128, imm8VEX.128.66.0F3A.W1 61 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpestrm<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpestrm<T, U, V>,

VPCMPESTRM instruction

InstructionOpcodeCPUID
VPCMPESTRM xmm1, xmm2/m128, imm8VEX.128.66.0F3A.W0 60 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpestrm64<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpestrm64<T, U, V>,

VPCMPESTRM64 instruction

InstructionOpcodeCPUID
VPCMPESTRM64 xmm1, xmm2/m128, imm8VEX.128.66.0F3A.W1 60 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpfalseb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpfalseb<T, U, V>,

VPCMPFALSEB instruction

InstructionOpcodeCPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpfalsed<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpfalsed<T, U, V>,

VPCMPFALSED instruction

InstructionOpcodeCPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpfalseq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpfalseq<T, U, V>,

VPCMPFALSEQ instruction

InstructionOpcodeCPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpfalseub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpfalseub<T, U, V>,

VPCMPFALSEUB instruction

InstructionOpcodeCPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpfalseud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpfalseud<T, U, V>,

VPCMPFALSEUD instruction

InstructionOpcodeCPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpfalseuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpfalseuq<T, U, V>,

VPCMPFALSEUQ instruction

InstructionOpcodeCPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpfalseuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpfalseuw<T, U, V>,

VPCMPFALSEUW instruction

InstructionOpcodeCPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpfalsew<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpfalsew<T, U, V>,

VPCMPFALSEW instruction

InstructionOpcodeCPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpgtb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpgtb<T, U, V>,

VPCMPGTB instruction

InstructionOpcodeCPUID
VPCMPGTB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 64 /rAVX
VPCMPGTB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 64 /rAVX2
VPCMPGTB k1 {k2}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 64 /rAVX512VL AVX512BW
VPCMPGTB k1 {k2}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 64 /rAVX512VL AVX512BW
VPCMPGTB k1 {k2}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 64 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpgtd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpgtd<T, U, V>,

VPCMPGTD instruction

InstructionOpcodeCPUID
VPCMPGTD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 66 /rAVX
VPCMPGTD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 66 /rAVX2
VPCMPGTD k1 {k2}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 66 /rAVX512VL AVX512F
VPCMPGTD k1 {k2}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 66 /rAVX512VL AVX512F
VPCMPGTD k1 {k2}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 66 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpgtq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpgtq<T, U, V>,

VPCMPGTQ instruction

InstructionOpcodeCPUID
VPCMPGTQ xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 37 /rAVX
VPCMPGTQ ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 37 /rAVX2
VPCMPGTQ k1 {k2}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 37 /rAVX512VL AVX512F
VPCMPGTQ k1 {k2}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 37 /rAVX512VL AVX512F
VPCMPGTQ k1 {k2}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 37 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpgtw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpgtw<T, U, V>,

VPCMPGTW instruction

InstructionOpcodeCPUID
VPCMPGTW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 65 /rAVX
VPCMPGTW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 65 /rAVX2
VPCMPGTW k1 {k2}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 65 /rAVX512VL AVX512BW
VPCMPGTW k1 {k2}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 65 /rAVX512VL AVX512BW
VPCMPGTW k1 {k2}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 65 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpistri<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpistri<T, U, V>,

VPCMPISTRI instruction

InstructionOpcodeCPUID
VPCMPISTRI xmm1, xmm2/m128, imm8VEX.128.66.0F3A.WIG 63 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpistrm<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpistrm<T, U, V>,

VPCMPISTRM instruction

InstructionOpcodeCPUID
VPCMPISTRM xmm1, xmm2/m128, imm8VEX.128.66.0F3A.WIG 62 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpleb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpleb<T, U, V>,

VPCMPLEB instruction

InstructionOpcodeCPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpled<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpled<T, U, V>,

VPCMPLED instruction

InstructionOpcodeCPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpleq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpleq<T, U, V>,

VPCMPLEQ instruction

InstructionOpcodeCPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpleub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpleub<T, U, V>,

VPCMPLEUB instruction

InstructionOpcodeCPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpleud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpleud<T, U, V>,

VPCMPLEUD instruction

InstructionOpcodeCPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpleuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpleuq<T, U, V>,

VPCMPLEUQ instruction

InstructionOpcodeCPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpleuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpleuw<T, U, V>,

VPCMPLEUW instruction

InstructionOpcodeCPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmplew<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmplew<T, U, V>,

VPCMPLEW instruction

InstructionOpcodeCPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpltb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpltb<T, U, V>,

VPCMPLTB instruction

InstructionOpcodeCPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpltd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpltd<T, U, V>,

VPCMPLTD instruction

InstructionOpcodeCPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpltq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpltq<T, U, V>,

VPCMPLTQ instruction

InstructionOpcodeCPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpltub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpltub<T, U, V>,

VPCMPLTUB instruction

InstructionOpcodeCPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpltud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpltud<T, U, V>,

VPCMPLTUD instruction

InstructionOpcodeCPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpltuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpltuq<T, U, V>,

VPCMPLTUQ instruction

InstructionOpcodeCPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpltuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpltuw<T, U, V>,

VPCMPLTUW instruction

InstructionOpcodeCPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpltw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpltw<T, U, V>,

VPCMPLTW instruction

InstructionOpcodeCPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpneqb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpneqb<T, U, V>,

VPCMPNEQB instruction

InstructionOpcodeCPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpneqd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpneqd<T, U, V>,

VPCMPNEQD instruction

InstructionOpcodeCPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpneqq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpneqq<T, U, V>,

VPCMPNEQQ instruction

InstructionOpcodeCPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnequb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnequb<T, U, V>,

VPCMPNEQUB instruction

InstructionOpcodeCPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnequd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnequd<T, U, V>,

VPCMPNEQUD instruction

InstructionOpcodeCPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnequq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnequq<T, U, V>,

VPCMPNEQUQ instruction

InstructionOpcodeCPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnequw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnequw<T, U, V>,

VPCMPNEQUW instruction

InstructionOpcodeCPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpneqw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpneqw<T, U, V>,

VPCMPNEQW instruction

InstructionOpcodeCPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnleb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnleb<T, U, V>,

VPCMPNLEB instruction

InstructionOpcodeCPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnled<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnled<T, U, V>,

VPCMPNLED instruction

InstructionOpcodeCPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnleq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnleq<T, U, V>,

VPCMPNLEQ instruction

InstructionOpcodeCPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnleub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnleub<T, U, V>,

VPCMPNLEUB instruction

InstructionOpcodeCPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnleud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnleud<T, U, V>,

VPCMPNLEUD instruction

InstructionOpcodeCPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnleuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnleuq<T, U, V>,

VPCMPNLEUQ instruction

InstructionOpcodeCPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnleuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnleuw<T, U, V>,

VPCMPNLEUW instruction

InstructionOpcodeCPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnlew<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnlew<T, U, V>,

VPCMPNLEW instruction

InstructionOpcodeCPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnltb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnltb<T, U, V>,

VPCMPNLTB instruction

InstructionOpcodeCPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnltd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnltd<T, U, V>,

VPCMPNLTD instruction

InstructionOpcodeCPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnltq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnltq<T, U, V>,

VPCMPNLTQ instruction

InstructionOpcodeCPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnltub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnltub<T, U, V>,

VPCMPNLTUB instruction

InstructionOpcodeCPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnltud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnltud<T, U, V>,

VPCMPNLTUD instruction

InstructionOpcodeCPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnltuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnltuq<T, U, V>,

VPCMPNLTUQ instruction

InstructionOpcodeCPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnltuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnltuw<T, U, V>,

VPCMPNLTUW instruction

InstructionOpcodeCPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmpnltw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmpnltw<T, U, V>,

VPCMPNLTW instruction

InstructionOpcodeCPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpcmptrueb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmptrueb<T, U, V>,

VPCMPTRUEB instruction

InstructionOpcodeCPUID
VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3F /r ibAVX512VL AVX512BW
VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmptrued<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmptrued<T, U, V>,

VPCMPTRUED instruction

InstructionOpcodeCPUID
VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1F /r ibAVX512VL AVX512F
VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmptrueq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmptrueq<T, U, V>,

VPCMPTRUEQ instruction

InstructionOpcodeCPUID
VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1F /r ibAVX512VL AVX512F
VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1F /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmptrueub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmptrueub<T, U, V>,

VPCMPTRUEUB instruction

InstructionOpcodeCPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmptrueud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmptrueud<T, U, V>,

VPCMPTRUEUD instruction

InstructionOpcodeCPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmptrueuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmptrueuq<T, U, V>,

VPCMPTRUEUQ instruction

InstructionOpcodeCPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmptrueuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmptrueuw<T, U, V>,

VPCMPTRUEUW instruction

InstructionOpcodeCPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcmptruew<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcmptruew<T, U, V>,

VPCMPTRUEW instruction

InstructionOpcodeCPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W0 3E /r ibAVX512VL AVX512BW
VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W0 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 1E /r ibAVX512VL AVX512F
VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 1E /r ibAVX512VL AVX512F
VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 1E /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3E /r ibAVX512VL AVX512BW
VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3E /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 3F /r ibAVX512VL AVX512BW
VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 3F /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpcomeqb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomeqb<T, U, V>,

VPCOMEQB instruction

InstructionOpcodeCPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomeqd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomeqd<T, U, V>,

VPCOMEQD instruction

InstructionOpcodeCPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomeqq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomeqq<T, U, V>,

VPCOMEQQ instruction

InstructionOpcodeCPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomequb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomequb<T, U, V>,

VPCOMEQUB instruction

InstructionOpcodeCPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomequd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomequd<T, U, V>,

VPCOMEQUD instruction

InstructionOpcodeCPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomequq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomequq<T, U, V>,

VPCOMEQUQ instruction

InstructionOpcodeCPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomequw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomequw<T, U, V>,

VPCOMEQUW instruction

InstructionOpcodeCPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 ED /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomeqw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomeqw<T, U, V>,

VPCOMEQW instruction

InstructionOpcodeCPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CD /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomfalseb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomfalseb<T, U, V>,

VPCOMFALSEB instruction

InstructionOpcodeCPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomfalsed<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomfalsed<T, U, V>,

VPCOMFALSED instruction

InstructionOpcodeCPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomfalseq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomfalseq<T, U, V>,

VPCOMFALSEQ instruction

InstructionOpcodeCPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomfalseub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomfalseub<T, U, V>,

VPCOMFALSEUB instruction

InstructionOpcodeCPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomfalseud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomfalseud<T, U, V>,

VPCOMFALSEUD instruction

InstructionOpcodeCPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomfalseuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomfalseuq<T, U, V>,

VPCOMFALSEUQ instruction

InstructionOpcodeCPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomfalseuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomfalseuw<T, U, V>,

VPCOMFALSEUW instruction

InstructionOpcodeCPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 ED /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomfalsew<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomfalsew<T, U, V>,

VPCOMFALSEW instruction

InstructionOpcodeCPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CD /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgeb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgeb<T, U, V>,

VPCOMGEB instruction

InstructionOpcodeCPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomged<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomged<T, U, V>,

VPCOMGED instruction

InstructionOpcodeCPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgeq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgeq<T, U, V>,

VPCOMGEQ instruction

InstructionOpcodeCPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgeub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgeub<T, U, V>,

VPCOMGEUB instruction

InstructionOpcodeCPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgeud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgeud<T, U, V>,

VPCOMGEUD instruction

InstructionOpcodeCPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgeuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgeuq<T, U, V>,

VPCOMGEUQ instruction

InstructionOpcodeCPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgeuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgeuw<T, U, V>,

VPCOMGEUW instruction

InstructionOpcodeCPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 ED /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgew<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgew<T, U, V>,

VPCOMGEW instruction

InstructionOpcodeCPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CD /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgtb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgtb<T, U, V>,

VPCOMGTB instruction

InstructionOpcodeCPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgtd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgtd<T, U, V>,

VPCOMGTD instruction

InstructionOpcodeCPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgtq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgtq<T, U, V>,

VPCOMGTQ instruction

InstructionOpcodeCPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgtub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgtub<T, U, V>,

VPCOMGTUB instruction

InstructionOpcodeCPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgtud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgtud<T, U, V>,

VPCOMGTUD instruction

InstructionOpcodeCPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgtuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgtuq<T, U, V>,

VPCOMGTUQ instruction

InstructionOpcodeCPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgtuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgtuw<T, U, V>,

VPCOMGTUW instruction

InstructionOpcodeCPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 ED /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomgtw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomgtw<T, U, V>,

VPCOMGTW instruction

InstructionOpcodeCPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CD /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomleb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomleb<T, U, V>,

VPCOMLEB instruction

InstructionOpcodeCPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomled<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomled<T, U, V>,

VPCOMLED instruction

InstructionOpcodeCPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomleq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomleq<T, U, V>,

VPCOMLEQ instruction

InstructionOpcodeCPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomleub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomleub<T, U, V>,

VPCOMLEUB instruction

InstructionOpcodeCPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomleud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomleud<T, U, V>,

VPCOMLEUD instruction

InstructionOpcodeCPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomleuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomleuq<T, U, V>,

VPCOMLEUQ instruction

InstructionOpcodeCPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomleuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomleuw<T, U, V>,

VPCOMLEUW instruction

InstructionOpcodeCPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 ED /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomlew<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomlew<T, U, V>,

VPCOMLEW instruction

InstructionOpcodeCPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CD /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomltb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomltb<T, U, V>,

VPCOMLTB instruction

InstructionOpcodeCPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomltd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomltd<T, U, V>,

VPCOMLTD instruction

InstructionOpcodeCPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomltq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomltq<T, U, V>,

VPCOMLTQ instruction

InstructionOpcodeCPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomltub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomltub<T, U, V>,

VPCOMLTUB instruction

InstructionOpcodeCPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomltud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomltud<T, U, V>,

VPCOMLTUD instruction

InstructionOpcodeCPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomltuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomltuq<T, U, V>,

VPCOMLTUQ instruction

InstructionOpcodeCPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomltuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomltuw<T, U, V>,

VPCOMLTUW instruction

InstructionOpcodeCPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 ED /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomltw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomltw<T, U, V>,

VPCOMLTW instruction

InstructionOpcodeCPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CD /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomneqb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomneqb<T, U, V>,

VPCOMNEQB instruction

InstructionOpcodeCPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomneqd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomneqd<T, U, V>,

VPCOMNEQD instruction

InstructionOpcodeCPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomneqq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomneqq<T, U, V>,

VPCOMNEQQ instruction

InstructionOpcodeCPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomnequb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomnequb<T, U, V>,

VPCOMNEQUB instruction

InstructionOpcodeCPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomnequd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomnequd<T, U, V>,

VPCOMNEQUD instruction

InstructionOpcodeCPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomnequq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomnequq<T, U, V>,

VPCOMNEQUQ instruction

InstructionOpcodeCPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomnequw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomnequw<T, U, V>,

VPCOMNEQUW instruction

InstructionOpcodeCPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 ED /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomneqw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomneqw<T, U, V>,

VPCOMNEQW instruction

InstructionOpcodeCPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CD /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcompressb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpcompressb<T, U>,

VPCOMPRESSB instruction

InstructionOpcodeCPUID
VPCOMPRESSB xmm1/m128 {k1}{z}, xmm2EVEX.128.66.0F38.W0 63 /rAVX512VL AVX512_VBMI2
VPCOMPRESSB ymm1/m256 {k1}{z}, ymm2EVEX.256.66.0F38.W0 63 /rAVX512VL AVX512_VBMI2
VPCOMPRESSB zmm1/m512 {k1}{z}, zmm2EVEX.512.66.0F38.W0 63 /rAVX512_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
Source

pub fn vpcompressd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpcompressd<T, U>,

VPCOMPRESSD instruction

InstructionOpcodeCPUID
VPCOMPRESSD xmm1/m128 {k1}{z}, xmm2EVEX.128.66.0F38.W0 8B /rAVX512VL AVX512F
VPCOMPRESSD ymm1/m256 {k1}{z}, ymm2EVEX.256.66.0F38.W0 8B /rAVX512VL AVX512F
VPCOMPRESSD zmm1/m512 {k1}{z}, zmm2EVEX.512.66.0F38.W0 8B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpcompressq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpcompressq<T, U>,

VPCOMPRESSQ instruction

InstructionOpcodeCPUID
VPCOMPRESSQ xmm1/m128 {k1}{z}, xmm2EVEX.128.66.0F38.W1 8B /rAVX512VL AVX512F
VPCOMPRESSQ ymm1/m256 {k1}{z}, ymm2EVEX.256.66.0F38.W1 8B /rAVX512VL AVX512F
VPCOMPRESSQ zmm1/m512 {k1}{z}, zmm2EVEX.512.66.0F38.W1 8B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpcompressw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpcompressw<T, U>,

VPCOMPRESSW instruction

InstructionOpcodeCPUID
VPCOMPRESSW xmm1/m128 {k1}{z}, xmm2EVEX.128.66.0F38.W1 63 /rAVX512VL AVX512_VBMI2
VPCOMPRESSW ymm1/m256 {k1}{z}, ymm2EVEX.256.66.0F38.W1 63 /rAVX512VL AVX512_VBMI2
VPCOMPRESSW zmm1/m512 {k1}{z}, zmm2EVEX.512.66.0F38.W1 63 /rAVX512_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
Source

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

InstructionOpcodeCPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpcomtrueb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomtrueb<T, U, V>,

VPCOMTRUEB instruction

InstructionOpcodeCPUID
VPCOMB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomtrued<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomtrued<T, U, V>,

VPCOMTRUED instruction

InstructionOpcodeCPUID
VPCOMD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomtrueq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomtrueq<T, U, V>,

VPCOMTRUEQ instruction

InstructionOpcodeCPUID
VPCOMQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomtrueub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomtrueub<T, U, V>,

VPCOMTRUEUB instruction

InstructionOpcodeCPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomtrueud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomtrueud<T, U, V>,

VPCOMTRUEUD instruction

InstructionOpcodeCPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomtrueuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomtrueuq<T, U, V>,

VPCOMTRUEUQ instruction

InstructionOpcodeCPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomtrueuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomtrueuw<T, U, V>,

VPCOMTRUEUW instruction

InstructionOpcodeCPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 ED /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpcomtruew<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpcomtruew<T, U, V>,

VPCOMTRUEW instruction

InstructionOpcodeCPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CD /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPCOMUB xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EC /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCOMUD xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EE /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCOMUQ xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 EF /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCOMUW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 ED /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPCOMW xmm1, xmm2, xmm3/m128, imm8XOP.128.X8.W0 CD /r ibXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpconflictd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpconflictd<T, U>,

VPCONFLICTD instruction

InstructionOpcodeCPUID
VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.0F38.W0 C4 /rAVX512VL AVX512CD
VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.0F38.W0 C4 /rAVX512VL AVX512CD
VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcstEVEX.512.66.0F38.W0 C4 /rAVX512CD
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpconflictq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpconflictq<T, U>,

VPCONFLICTQ instruction

InstructionOpcodeCPUID
VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F38.W1 C4 /rAVX512VL AVX512CD
VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F38.W1 C4 /rAVX512VL AVX512CD
VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcstEVEX.512.66.0F38.W1 C4 /rAVX512CD
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpdpbssd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpbssd<T, U, V>,

VPDPBSSD instruction

InstructionOpcodeCPUID
VPDPBSSD xmm1, xmm2, xmm3/m128VEX.128.F2.0F38.W0 50 /rAVX-VNNI-INT8
VPDPBSSD ymm1, ymm2, ymm3/m256VEX.256.F2.0F38.W0 50 /rAVX-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
Source

pub fn vpdpbssds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpbssds<T, U, V>,

VPDPBSSDS instruction

InstructionOpcodeCPUID
VPDPBSSDS xmm1, xmm2, xmm3/m128VEX.128.F2.0F38.W0 51 /rAVX-VNNI-INT8
VPDPBSSDS ymm1, ymm2, ymm3/m256VEX.256.F2.0F38.W0 51 /rAVX-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
Source

pub fn vpdpbsud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpbsud<T, U, V>,

VPDPBSUD instruction

InstructionOpcodeCPUID
VPDPBSUD xmm1, xmm2, xmm3/m128VEX.128.F3.0F38.W0 50 /rAVX-VNNI-INT8
VPDPBSUD ymm1, ymm2, ymm3/m256VEX.256.F3.0F38.W0 50 /rAVX-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
Source

pub fn vpdpbsuds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpbsuds<T, U, V>,

VPDPBSUDS instruction

InstructionOpcodeCPUID
VPDPBSUDS xmm1, xmm2, xmm3/m128VEX.128.F3.0F38.W0 51 /rAVX-VNNI-INT8
VPDPBSUDS ymm1, ymm2, ymm3/m256VEX.256.F3.0F38.W0 51 /rAVX-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
Source

pub fn vpdpbusd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpbusd<T, U, V>,

VPDPBUSD instruction

InstructionOpcodeCPUID
VPDPBUSD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 50 /rAVX-VNNI
VPDPBUSD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 50 /rAVX-VNNI
VPDPBUSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 50 /rAVX512VL AVX512_VNNI
VPDPBUSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 50 /rAVX512VL AVX512_VNNI
VPDPBUSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 50 /rAVX512_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
Source

pub fn vpdpbusds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpbusds<T, U, V>,

VPDPBUSDS instruction

InstructionOpcodeCPUID
VPDPBUSDS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 51 /rAVX-VNNI
VPDPBUSDS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 51 /rAVX-VNNI
VPDPBUSDS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 51 /rAVX512VL AVX512_VNNI
VPDPBUSDS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 51 /rAVX512VL AVX512_VNNI
VPDPBUSDS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 51 /rAVX512_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
Source

pub fn vpdpbuud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpbuud<T, U, V>,

VPDPBUUD instruction

InstructionOpcodeCPUID
VPDPBUUD xmm1, xmm2, xmm3/m128VEX.128.0F38.W0 50 /rAVX-VNNI-INT8
VPDPBUUD ymm1, ymm2, ymm3/m256VEX.256.0F38.W0 50 /rAVX-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
Source

pub fn vpdpbuuds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpbuuds<T, U, V>,

VPDPBUUDS instruction

InstructionOpcodeCPUID
VPDPBUUDS xmm1, xmm2, xmm3/m128VEX.128.0F38.W0 51 /rAVX-VNNI-INT8
VPDPBUUDS ymm1, ymm2, ymm3/m256VEX.256.0F38.W0 51 /rAVX-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
Source

pub fn vpdpwssd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpwssd<T, U, V>,

VPDPWSSD instruction

InstructionOpcodeCPUID
VPDPWSSD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 52 /rAVX-VNNI
VPDPWSSD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 52 /rAVX-VNNI
VPDPWSSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 52 /rAVX512VL AVX512_VNNI
VPDPWSSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 52 /rAVX512VL AVX512_VNNI
VPDPWSSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 52 /rAVX512_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
Source

pub fn vpdpwssds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpwssds<T, U, V>,

VPDPWSSDS instruction

InstructionOpcodeCPUID
VPDPWSSDS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 53 /rAVX-VNNI
VPDPWSSDS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 53 /rAVX-VNNI
VPDPWSSDS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 53 /rAVX512VL AVX512_VNNI
VPDPWSSDS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 53 /rAVX512VL AVX512_VNNI
VPDPWSSDS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 53 /rAVX512_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
Source

pub fn vpdpwsud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpwsud<T, U, V>,

VPDPWSUD instruction

InstructionOpcodeCPUID
VPDPWSUD xmm1, xmm2, xmm3/m128VEX.128.F3.0F38.W0 D2 /rAVX-VNNI-INT16
VPDPWSUD ymm1, ymm2, ymm3/m256VEX.256.F3.0F38.W0 D2 /rAVX-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
Source

pub fn vpdpwsuds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpwsuds<T, U, V>,

VPDPWSUDS instruction

InstructionOpcodeCPUID
VPDPWSUDS xmm1, xmm2, xmm3/m128VEX.128.F3.0F38.W0 D3 /rAVX-VNNI-INT16
VPDPWSUDS ymm1, ymm2, ymm3/m256VEX.256.F3.0F38.W0 D3 /rAVX-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
Source

pub fn vpdpwusd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpwusd<T, U, V>,

VPDPWUSD instruction

InstructionOpcodeCPUID
VPDPWUSD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 D2 /rAVX-VNNI-INT16
VPDPWUSD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 D2 /rAVX-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
Source

pub fn vpdpwusds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpwusds<T, U, V>,

VPDPWUSDS instruction

InstructionOpcodeCPUID
VPDPWUSDS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 D3 /rAVX-VNNI-INT16
VPDPWUSDS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 D3 /rAVX-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
Source

pub fn vpdpwuud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpwuud<T, U, V>,

VPDPWUUD instruction

InstructionOpcodeCPUID
VPDPWUUD xmm1, xmm2, xmm3/m128VEX.128.0F38.W0 D2 /rAVX-VNNI-INT16
VPDPWUUD ymm1, ymm2, ymm3/m256VEX.256.0F38.W0 D2 /rAVX-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
Source

pub fn vpdpwuuds<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpdpwuuds<T, U, V>,

VPDPWUUDS instruction

InstructionOpcodeCPUID
VPDPWUUDS xmm1, xmm2, xmm3/m128VEX.128.0F38.W0 D3 /rAVX-VNNI-INT16
VPDPWUUDS ymm1, ymm2, ymm3/m256VEX.256.0F38.W0 D3 /rAVX-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
Source

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

InstructionOpcodeCPUID
VPERM2F128 ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.W0 06 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPERM2I128 ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F3A.W0 46 /r ibAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpermb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermb<T, U, V>,

VPERMB instruction

InstructionOpcodeCPUID
VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W0 8D /rAVX512VL AVX512_VBMI
VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W0 8D /rAVX512VL AVX512_VBMI
VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W0 8D /rAVX512_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
Source

pub fn vpermd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermd<T, U, V>,

VPERMD instruction

InstructionOpcodeCPUID
VPERMD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 36 /rAVX2
VPERMD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 36 /rAVX512VL AVX512F
VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 36 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermi2b<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermi2b<T, U, V>,

VPERMI2B instruction

InstructionOpcodeCPUID
VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W0 75 /rAVX512VL AVX512_VBMI
VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W0 75 /rAVX512VL AVX512_VBMI
VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W0 75 /rAVX512_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
Source

pub fn vpermi2d<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermi2d<T, U, V>,

VPERMI2D instruction

InstructionOpcodeCPUID
VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 76 /rAVX512VL AVX512F
VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 76 /rAVX512VL AVX512F
VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 76 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermi2pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermi2pd<T, U, V>,

VPERMI2PD instruction

InstructionOpcodeCPUID
VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 77 /rAVX512VL AVX512F
VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 77 /rAVX512VL AVX512F
VPERMI2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 77 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermi2ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermi2ps<T, U, V>,

VPERMI2PS instruction

InstructionOpcodeCPUID
VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 77 /rAVX512VL AVX512F
VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 77 /rAVX512VL AVX512F
VPERMI2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 77 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermi2q<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermi2q<T, U, V>,

VPERMI2Q instruction

InstructionOpcodeCPUID
VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 76 /rAVX512VL AVX512F
VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 76 /rAVX512VL AVX512F
VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 76 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermi2w<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermi2w<T, U, V>,

VPERMI2W instruction

InstructionOpcodeCPUID
VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 75 /rAVX512VL AVX512BW
VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 75 /rAVX512VL AVX512BW
VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 75 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPERMIL2PD xmm1, xmm2, xmm3/m128, xmm4, imm4VEX.128.66.0F3A.W0 49 /r /is5XOP
VPERMIL2PD ymm1, ymm2, ymm3/m256, ymm4, imm4VEX.256.66.0F3A.W0 49 /r /is5XOP
VPERMIL2PD xmm1, xmm2, xmm3, xmm4/m128, imm4VEX.128.66.0F3A.W1 49 /r /is5XOP
VPERMIL2PD ymm1, ymm2, ymm3, ymm4/m256, imm4VEX.256.66.0F3A.W1 49 /r /is5XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPERMIL2PS xmm1, xmm2, xmm3/m128, xmm4, imm4VEX.128.66.0F3A.W0 48 /r /is5XOP
VPERMIL2PS ymm1, ymm2, ymm3/m256, ymm4, imm4VEX.256.66.0F3A.W0 48 /r /is5XOP
VPERMIL2PS xmm1, xmm2, xmm3, xmm4/m128, imm4VEX.128.66.0F3A.W1 48 /r /is5XOP
VPERMIL2PS ymm1, ymm2, ymm3, ymm4/m256, imm4VEX.256.66.0F3A.W1 48 /r /is5XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpermilpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermilpd<T, U, V>,

VPERMILPD instruction

InstructionOpcodeCPUID
VPERMILPD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 0D /rAVX
VPERMILPD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 0D /rAVX
VPERMILPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 0D /rAVX512VL AVX512F
VPERMILPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 0D /rAVX512VL AVX512F
VPERMILPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 0D /rAVX512F
VPERMILPD xmm1, xmm2/m128, imm8VEX.128.66.0F3A.W0 05 /r ibAVX
VPERMILPD ymm1, ymm2/m256, imm8VEX.256.66.0F3A.W0 05 /r ibAVX
VPERMILPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 05 /r ibAVX512VL AVX512F
VPERMILPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 05 /r ibAVX512VL AVX512F
VPERMILPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 05 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermilps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermilps<T, U, V>,

VPERMILPS instruction

InstructionOpcodeCPUID
VPERMILPS xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 0C /rAVX
VPERMILPS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 0C /rAVX
VPERMILPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 0C /rAVX512VL AVX512F
VPERMILPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 0C /rAVX512VL AVX512F
VPERMILPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 0C /rAVX512F
VPERMILPS xmm1, xmm2/m128, imm8VEX.128.66.0F3A.W0 04 /r ibAVX
VPERMILPS ymm1, ymm2/m256, imm8VEX.256.66.0F3A.W0 04 /r ibAVX
VPERMILPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 04 /r ibAVX512VL AVX512F
VPERMILPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 04 /r ibAVX512VL AVX512F
VPERMILPS zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 04 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermpd<T, U, V>,

VPERMPD instruction

InstructionOpcodeCPUID
VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 16 /rAVX512VL AVX512F
VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 16 /rAVX512F
VPERMPD ymm1, ymm2/m256, imm8VEX.256.66.0F3A.W1 01 /r ibAVX2
VPERMPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 01 /r ibAVX512VL AVX512F
VPERMPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 01 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermps<T, U, V>,

VPERMPS instruction

InstructionOpcodeCPUID
VPERMPS ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 16 /rAVX2
VPERMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 16 /rAVX512VL AVX512F
VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 16 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermq<T, U, V>,

VPERMQ instruction

InstructionOpcodeCPUID
VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 36 /rAVX512VL AVX512F
VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 36 /rAVX512F
VPERMQ ymm1, ymm2/m256, imm8VEX.256.66.0F3A.W1 00 /r ibAVX2
VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 00 /r ibAVX512VL AVX512F
VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 00 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermt2b<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermt2b<T, U, V>,

VPERMT2B instruction

InstructionOpcodeCPUID
VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W0 7D /rAVX512VL AVX512_VBMI
VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W0 7D /rAVX512VL AVX512_VBMI
VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W0 7D /rAVX512_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
Source

pub fn vpermt2d<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermt2d<T, U, V>,

VPERMT2D instruction

InstructionOpcodeCPUID
VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 7E /rAVX512VL AVX512F
VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 7E /rAVX512VL AVX512F
VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 7E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermt2pd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermt2pd<T, U, V>,

VPERMT2PD instruction

InstructionOpcodeCPUID
VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 7F /rAVX512VL AVX512F
VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 7F /rAVX512VL AVX512F
VPERMT2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 7F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermt2ps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermt2ps<T, U, V>,

VPERMT2PS instruction

InstructionOpcodeCPUID
VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 7F /rAVX512VL AVX512F
VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 7F /rAVX512VL AVX512F
VPERMT2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 7F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermt2q<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermt2q<T, U, V>,

VPERMT2Q instruction

InstructionOpcodeCPUID
VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 7E /rAVX512VL AVX512F
VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 7E /rAVX512VL AVX512F
VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 7E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermt2w<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermt2w<T, U, V>,

VPERMT2W instruction

InstructionOpcodeCPUID
VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 7D /rAVX512VL AVX512BW
VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 7D /rAVX512VL AVX512BW
VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 7D /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpermw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpermw<T, U, V>,

VPERMW instruction

InstructionOpcodeCPUID
VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 8D /rAVX512VL AVX512BW
VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 8D /rAVX512VL AVX512BW
VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 8D /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpexpandb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpexpandb<T, U>,

VPEXPANDB instruction

InstructionOpcodeCPUID
VPEXPANDB xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.W0 62 /rAVX512VL AVX512_VBMI2
VPEXPANDB ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.W0 62 /rAVX512VL AVX512_VBMI2
VPEXPANDB zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.W0 62 /rAVX512_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
Source

pub fn vpexpandd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpexpandd<T, U>,

VPEXPANDD instruction

InstructionOpcodeCPUID
VPEXPANDD xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.W0 89 /rAVX512VL AVX512F
VPEXPANDD ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.W0 89 /rAVX512VL AVX512F
VPEXPANDD zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.W0 89 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpexpandq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpexpandq<T, U>,

VPEXPANDQ instruction

InstructionOpcodeCPUID
VPEXPANDQ xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.W1 89 /rAVX512VL AVX512F
VPEXPANDQ ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.W1 89 /rAVX512VL AVX512F
VPEXPANDQ zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.W1 89 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpexpandw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpexpandw<T, U>,

VPEXPANDW instruction

InstructionOpcodeCPUID
VPEXPANDW xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.W1 62 /rAVX512VL AVX512_VBMI2
VPEXPANDW ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.W1 62 /rAVX512VL AVX512_VBMI2
VPEXPANDW zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.W1 62 /rAVX512_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
Source

pub fn vpextrb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpextrb<T, U, V>,

VPEXTRB instruction

InstructionOpcodeCPUID
VPEXTRB r32/m8, xmm2, imm8VEX.128.66.0F3A.W0 14 /r ibAVX
VPEXTRB r64/m8, xmm2, imm8VEX.128.66.0F3A.W1 14 /r ibAVX
VPEXTRB r32/m8, xmm2, imm8EVEX.128.66.0F3A.W0 14 /r ibAVX512BW
VPEXTRB r64/m8, xmm2, imm8EVEX.128.66.0F3A.W1 14 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpextrd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpextrd<T, U, V>,

VPEXTRD instruction

InstructionOpcodeCPUID
VPEXTRD r/m32, xmm2, imm8VEX.128.66.0F3A.W0 16 /r ibAVX
VPEXTRD r/m32, xmm2, imm8EVEX.128.66.0F3A.W0 16 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpextrq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpextrq<T, U, V>,

VPEXTRQ instruction

InstructionOpcodeCPUID
VPEXTRQ r/m64, xmm2, imm8VEX.128.66.0F3A.W1 16 /r ibAVX
VPEXTRQ r/m64, xmm2, imm8EVEX.128.66.0F3A.W1 16 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpextrw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpextrw<T, U, V>,

VPEXTRW instruction

InstructionOpcodeCPUID
VPEXTRW r32, xmm1, imm8VEX.128.66.0F.W0 C5 /r ibAVX
VPEXTRW r64, xmm1, imm8VEX.128.66.0F.W1 C5 /r ibAVX
VPEXTRW r32, xmm1, imm8EVEX.128.66.0F.W0 C5 /r ibAVX512BW
VPEXTRW r64, xmm1, imm8EVEX.128.66.0F.W1 C5 /r ibAVX512BW
VPEXTRW r32/m16, xmm2, imm8VEX.128.66.0F3A.W0 15 /r ibAVX
VPEXTRW r32/m16, xmm2, imm8EVEX.128.66.0F3A.W0 15 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpgatherdd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpgatherdd<T, U>,

VPGATHERDD instruction

InstructionOpcodeCPUID
VPGATHERDD xmm1 {k1}, vm32xEVEX.128.66.0F38.W0 90 /vsibAVX512VL AVX512F
VPGATHERDD ymm1 {k1}, vm32yEVEX.256.66.0F38.W0 90 /vsibAVX512VL AVX512F
VPGATHERDD zmm1 {k1}, vm32zEVEX.512.66.0F38.W0 90 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VPGATHERDD xmm1, vm32x, xmm2VEX.128.66.0F38.W0 90 /rAVX2
VPGATHERDD ymm1, vm32y, ymm2VEX.256.66.0F38.W0 90 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpgatherdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpgatherdq<T, U>,

VPGATHERDQ instruction

InstructionOpcodeCPUID
VPGATHERDQ xmm1 {k1}, vm32xEVEX.128.66.0F38.W1 90 /vsibAVX512VL AVX512F
VPGATHERDQ ymm1 {k1}, vm32xEVEX.256.66.0F38.W1 90 /vsibAVX512VL AVX512F
VPGATHERDQ zmm1 {k1}, vm32yEVEX.512.66.0F38.W1 90 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VPGATHERDQ xmm1, vm32x, xmm2VEX.128.66.0F38.W1 90 /rAVX2
VPGATHERDQ ymm1, vm32x, ymm2VEX.256.66.0F38.W1 90 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpgatherqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpgatherqd<T, U>,

VPGATHERQD instruction

InstructionOpcodeCPUID
VPGATHERQD xmm1 {k1}, vm64xEVEX.128.66.0F38.W0 91 /vsibAVX512VL AVX512F
VPGATHERQD xmm1 {k1}, vm64yEVEX.256.66.0F38.W0 91 /vsibAVX512VL AVX512F
VPGATHERQD ymm1 {k1}, vm64zEVEX.512.66.0F38.W0 91 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VPGATHERQD xmm1, vm64x, xmm2VEX.128.66.0F38.W0 91 /rAVX2
VPGATHERQD xmm1, vm64y, xmm2VEX.256.66.0F38.W0 91 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpgatherqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpgatherqq<T, U>,

VPGATHERQQ instruction

InstructionOpcodeCPUID
VPGATHERQQ xmm1 {k1}, vm64xEVEX.128.66.0F38.W1 91 /vsibAVX512VL AVX512F
VPGATHERQQ ymm1 {k1}, vm64yEVEX.256.66.0F38.W1 91 /vsibAVX512VL AVX512F
VPGATHERQQ zmm1 {k1}, vm64zEVEX.512.66.0F38.W1 91 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VPGATHERQQ xmm1, vm64x, xmm2VEX.128.66.0F38.W1 91 /rAVX2
VPGATHERQQ ymm1, vm64y, ymm2VEX.256.66.0F38.W1 91 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vphaddbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphaddbd<T, U>,

VPHADDBD instruction

InstructionOpcodeCPUID
VPHADDBD xmm1, xmm2/m128XOP.128.X9.W0 C2 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphaddbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphaddbq<T, U>,

VPHADDBQ instruction

InstructionOpcodeCPUID
VPHADDBQ xmm1, xmm2/m128XOP.128.X9.W0 C3 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphaddbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphaddbw<T, U>,

VPHADDBW instruction

InstructionOpcodeCPUID
VPHADDBW xmm1, xmm2/m128XOP.128.X9.W0 C1 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphaddd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVphaddd<T, U, V>,

VPHADDD instruction

InstructionOpcodeCPUID
VPHADDD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 02 /rAVX
VPHADDD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 02 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vphadddq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphadddq<T, U>,

VPHADDDQ instruction

InstructionOpcodeCPUID
VPHADDDQ xmm1, xmm2/m128XOP.128.X9.W0 CB /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphaddsw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVphaddsw<T, U, V>,

VPHADDSW instruction

InstructionOpcodeCPUID
VPHADDSW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 03 /rAVX
VPHADDSW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 03 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vphaddubd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphaddubd<T, U>,

VPHADDUBD instruction

InstructionOpcodeCPUID
VPHADDUBD xmm1, xmm2/m128XOP.128.X9.W0 D2 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphaddubq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphaddubq<T, U>,

VPHADDUBQ instruction

InstructionOpcodeCPUID
VPHADDUBQ xmm1, xmm2/m128XOP.128.X9.W0 D3 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphaddubw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphaddubw<T, U>,

VPHADDUBW instruction

InstructionOpcodeCPUID
VPHADDUBW xmm1, xmm2/m128XOP.128.X9.W0 D1 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphaddudq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphaddudq<T, U>,

VPHADDUDQ instruction

InstructionOpcodeCPUID
VPHADDUDQ xmm1, xmm2/m128XOP.128.X9.W0 DB /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphadduwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphadduwd<T, U>,

VPHADDUWD instruction

InstructionOpcodeCPUID
VPHADDUWD xmm1, xmm2/m128XOP.128.X9.W0 D6 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphadduwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphadduwq<T, U>,

VPHADDUWQ instruction

InstructionOpcodeCPUID
VPHADDUWQ xmm1, xmm2/m128XOP.128.X9.W0 D7 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphaddw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVphaddw<T, U, V>,

VPHADDW instruction

InstructionOpcodeCPUID
VPHADDW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 01 /rAVX
VPHADDW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 01 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vphaddwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphaddwd<T, U>,

VPHADDWD instruction

InstructionOpcodeCPUID
VPHADDWD xmm1, xmm2/m128XOP.128.X9.W0 C6 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphaddwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphaddwq<T, U>,

VPHADDWQ instruction

InstructionOpcodeCPUID
VPHADDWQ xmm1, xmm2/m128XOP.128.X9.W0 C7 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphminposuw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphminposuw<T, U>,

VPHMINPOSUW instruction

InstructionOpcodeCPUID
VPHMINPOSUW xmm1, xmm2/m128VEX.128.66.0F38.WIG 41 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphsubbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphsubbw<T, U>,

VPHSUBBW instruction

InstructionOpcodeCPUID
VPHSUBBW xmm1, xmm2/m128XOP.128.X9.W0 E1 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphsubd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVphsubd<T, U, V>,

VPHSUBD instruction

InstructionOpcodeCPUID
VPHSUBD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 06 /rAVX
VPHSUBD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 06 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vphsubdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphsubdq<T, U>,

VPHSUBDQ instruction

InstructionOpcodeCPUID
VPHSUBDQ xmm1, xmm2/m128XOP.128.X9.W0 E3 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vphsubsw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVphsubsw<T, U, V>,

VPHSUBSW instruction

InstructionOpcodeCPUID
VPHSUBSW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 07 /rAVX
VPHSUBSW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 07 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vphsubw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVphsubw<T, U, V>,

VPHSUBW instruction

InstructionOpcodeCPUID
VPHSUBW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 05 /rAVX
VPHSUBW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 05 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vphsubwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVphsubwd<T, U>,

VPHSUBWD instruction

InstructionOpcodeCPUID
VPHSUBWD xmm1, xmm2/m128XOP.128.X9.W0 E2 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VPINSRB xmm1, xmm2, r32/m8, imm8VEX.128.66.0F3A.W0 20 /r ibAVX
VPINSRB xmm1, xmm2, r64/m8, imm8VEX.128.66.0F3A.W1 20 /r ibAVX
VPINSRB xmm1, xmm2, r32/m8, imm8EVEX.128.66.0F3A.W0 20 /r ibAVX512BW
VPINSRB xmm1, xmm2, r64/m8, imm8EVEX.128.66.0F3A.W1 20 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPINSRD xmm1, xmm2, r/m32, imm8VEX.128.66.0F3A.W0 22 /r ibAVX
VPINSRD xmm1, xmm2, r/m32, imm8EVEX.128.66.0F3A.W0 22 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPINSRQ xmm1, xmm2, r/m64, imm8VEX.128.66.0F3A.W1 22 /r ibAVX
VPINSRQ xmm1, xmm2, r/m64, imm8EVEX.128.66.0F3A.W1 22 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPINSRW xmm1, xmm2, r32/m16, imm8VEX.128.66.0F.W0 C4 /r ibAVX
VPINSRW xmm1, xmm2, r64/m16, imm8VEX.128.66.0F.W1 C4 /r ibAVX
VPINSRW xmm1, xmm2, r32/m16, imm8EVEX.128.66.0F.W0 C4 /r ibAVX512BW
VPINSRW xmm1, xmm2, r64/m16, imm8EVEX.128.66.0F.W1 C4 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vplzcntd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVplzcntd<T, U>,

VPLZCNTD instruction

InstructionOpcodeCPUID
VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.0F38.W0 44 /rAVX512VL AVX512CD
VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.0F38.W0 44 /rAVX512VL AVX512CD
VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcstEVEX.512.66.0F38.W0 44 /rAVX512CD
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vplzcntq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVplzcntq<T, U>,

VPLZCNTQ instruction

InstructionOpcodeCPUID
VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F38.W1 44 /rAVX512VL AVX512CD
VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F38.W1 44 /rAVX512VL AVX512CD
VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcstEVEX.512.66.0F38.W1 44 /rAVX512CD
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

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

InstructionOpcodeCPUID
VPMACSDD xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 9E /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMACSDQH xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 9F /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMACSDQL xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 97 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMACSSDD xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 8E /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMACSSDQH xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 8F /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMACSSDQL xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 87 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMACSSWD xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 86 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMACSSWW xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 85 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMACSWD xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 96 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMACSWW xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 95 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMADCSSWD xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 A6 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPMADCSWD xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 B6 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vpmadd52huq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmadd52huq<T, U, V>,

VPMADD52HUQ instruction

InstructionOpcodeCPUID
VPMADD52HUQ xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 B5 /rAVX-IFMA
VPMADD52HUQ ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 B5 /rAVX-IFMA
VPMADD52HUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 B5 /rAVX512VL AVX512_IFMA
VPMADD52HUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 B5 /rAVX512VL AVX512_IFMA
VPMADD52HUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 B5 /rAVX512_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
Source

pub fn vpmadd52luq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmadd52luq<T, U, V>,

VPMADD52LUQ instruction

InstructionOpcodeCPUID
VPMADD52LUQ xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 B4 /rAVX-IFMA
VPMADD52LUQ ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 B4 /rAVX-IFMA
VPMADD52LUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 B4 /rAVX512VL AVX512_IFMA
VPMADD52LUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 B4 /rAVX512VL AVX512_IFMA
VPMADD52LUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 B4 /rAVX512_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
Source

pub fn vpmaddubsw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaddubsw<T, U, V>,

VPMADDUBSW instruction

InstructionOpcodeCPUID
VPMADDUBSW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 04 /rAVX
VPMADDUBSW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 04 /rAVX2
VPMADDUBSW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.WIG 04 /rAVX512VL AVX512BW
VPMADDUBSW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.WIG 04 /rAVX512VL AVX512BW
VPMADDUBSW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.WIG 04 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaddwd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaddwd<T, U, V>,

VPMADDWD instruction

InstructionOpcodeCPUID
VPMADDWD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG F5 /rAVX
VPMADDWD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG F5 /rAVX2
VPMADDWD xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG F5 /rAVX512VL AVX512BW
VPMADDWD ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG F5 /rAVX512VL AVX512BW
VPMADDWD zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG F5 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaskmovd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaskmovd<T, U, V>,

VPMASKMOVD instruction

InstructionOpcodeCPUID
VPMASKMOVD xmm1, xmm2, m128VEX.128.66.0F38.W0 8C /rAVX2
VPMASKMOVD ymm1, ymm2, m256VEX.256.66.0F38.W0 8C /rAVX2
VPMASKMOVD m128, xmm1, xmm2VEX.128.66.0F38.W0 8E /rAVX2
VPMASKMOVD m256, ymm1, ymm2VEX.256.66.0F38.W0 8E /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaskmovq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaskmovq<T, U, V>,

VPMASKMOVQ instruction

InstructionOpcodeCPUID
VPMASKMOVQ xmm1, xmm2, m128VEX.128.66.0F38.W1 8C /rAVX2
VPMASKMOVQ ymm1, ymm2, m256VEX.256.66.0F38.W1 8C /rAVX2
VPMASKMOVQ m128, xmm1, xmm2VEX.128.66.0F38.W1 8E /rAVX2
VPMASKMOVQ m256, ymm1, ymm2VEX.256.66.0F38.W1 8E /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaxsb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaxsb<T, U, V>,

VPMAXSB instruction

InstructionOpcodeCPUID
VPMAXSB xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 3C /rAVX
VPMAXSB ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 3C /rAVX2
VPMAXSB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.WIG 3C /rAVX512VL AVX512BW
VPMAXSB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.WIG 3C /rAVX512VL AVX512BW
VPMAXSB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.WIG 3C /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaxsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaxsd<T, U, V>,

VPMAXSD instruction

InstructionOpcodeCPUID
VPMAXSD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 3D /rAVX
VPMAXSD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 3D /rAVX2
VPMAXSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 3D /rAVX512VL AVX512F
VPMAXSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 3D /rAVX512VL AVX512F
VPMAXSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 3D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaxsq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaxsq<T, U, V>,

VPMAXSQ instruction

InstructionOpcodeCPUID
VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 3D /rAVX512VL AVX512F
VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 3D /rAVX512VL AVX512F
VPMAXSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 3D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaxsw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaxsw<T, U, V>,

VPMAXSW instruction

InstructionOpcodeCPUID
VPMAXSW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG EE /rAVX
VPMAXSW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG EE /rAVX2
VPMAXSW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG EE /rAVX512VL AVX512BW
VPMAXSW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG EE /rAVX512VL AVX512BW
VPMAXSW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG EE /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaxub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaxub<T, U, V>,

VPMAXUB instruction

InstructionOpcodeCPUID
VPMAXUB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG DE /rAVX
VPMAXUB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG DE /rAVX2
VPMAXUB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG DE /rAVX512VL AVX512BW
VPMAXUB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG DE /rAVX512VL AVX512BW
VPMAXUB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG DE /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaxud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaxud<T, U, V>,

VPMAXUD instruction

InstructionOpcodeCPUID
VPMAXUD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 3F /rAVX
VPMAXUD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 3F /rAVX2
VPMAXUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 3F /rAVX512VL AVX512F
VPMAXUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 3F /rAVX512VL AVX512F
VPMAXUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 3F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaxuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaxuq<T, U, V>,

VPMAXUQ instruction

InstructionOpcodeCPUID
VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 3F /rAVX512VL AVX512F
VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 3F /rAVX512VL AVX512F
VPMAXUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 3F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmaxuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmaxuw<T, U, V>,

VPMAXUW instruction

InstructionOpcodeCPUID
VPMAXUW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 3E /rAVX
VPMAXUW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 3E /rAVX2
VPMAXUW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.WIG 3E /rAVX512VL AVX512BW
VPMAXUW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.WIG 3E /rAVX512VL AVX512BW
VPMAXUW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.WIG 3E /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpminsb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpminsb<T, U, V>,

VPMINSB instruction

InstructionOpcodeCPUID
VPMINSB xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 38 /rAVX
VPMINSB ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 38 /rAVX2
VPMINSB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.WIG 38 /rAVX512VL AVX512BW
VPMINSB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.WIG 38 /rAVX512VL AVX512BW
VPMINSB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.WIG 38 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpminsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpminsd<T, U, V>,

VPMINSD instruction

InstructionOpcodeCPUID
VPMINSD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 39 /rAVX
VPMINSD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 39 /rAVX2
VPMINSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 39 /rAVX512VL AVX512F
VPMINSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 39 /rAVX512VL AVX512F
VPMINSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 39 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpminsq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpminsq<T, U, V>,

VPMINSQ instruction

InstructionOpcodeCPUID
VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 39 /rAVX512VL AVX512F
VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 39 /rAVX512VL AVX512F
VPMINSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 39 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpminsw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpminsw<T, U, V>,

VPMINSW instruction

InstructionOpcodeCPUID
VPMINSW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG EA /rAVX
VPMINSW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG EA /rAVX2
VPMINSW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG EA /rAVX512VL AVX512BW
VPMINSW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG EA /rAVX512VL AVX512BW
VPMINSW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG EA /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpminub<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpminub<T, U, V>,

VPMINUB instruction

InstructionOpcodeCPUID
VPMINUB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG DA /rAVX
VPMINUB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG DA /rAVX2
VPMINUB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG DA /rAVX512VL AVX512BW
VPMINUB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG DA /rAVX512VL AVX512BW
VPMINUB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG DA /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpminud<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpminud<T, U, V>,

VPMINUD instruction

InstructionOpcodeCPUID
VPMINUD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 3B /rAVX
VPMINUD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 3B /rAVX2
VPMINUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 3B /rAVX512VL AVX512F
VPMINUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 3B /rAVX512VL AVX512F
VPMINUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 3B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpminuq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpminuq<T, U, V>,

VPMINUQ instruction

InstructionOpcodeCPUID
VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 3B /rAVX512VL AVX512F
VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 3B /rAVX512VL AVX512F
VPMINUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 3B /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpminuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpminuw<T, U, V>,

VPMINUW instruction

InstructionOpcodeCPUID
VPMINUW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 3A /rAVX
VPMINUW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 3A /rAVX2
VPMINUW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.WIG 3A /rAVX512VL AVX512BW
VPMINUW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.WIG 3A /rAVX512VL AVX512BW
VPMINUW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.WIG 3A /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmovb2m<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovb2m<T, U>,

VPMOVB2M instruction

InstructionOpcodeCPUID
VPMOVB2M k1, xmm1EVEX.128.F3.0F38.W0 29 /rAVX512VL AVX512BW
VPMOVB2M k1, ymm1EVEX.256.F3.0F38.W0 29 /rAVX512VL AVX512BW
VPMOVB2M k1, zmm1EVEX.512.F3.0F38.W0 29 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovd2m<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovd2m<T, U>,

VPMOVD2M instruction

InstructionOpcodeCPUID
VPMOVD2M k1, xmm1EVEX.128.F3.0F38.W0 39 /rAVX512VL AVX512DQ
VPMOVD2M k1, ymm1EVEX.256.F3.0F38.W0 39 /rAVX512VL AVX512DQ
VPMOVD2M k1, zmm1EVEX.512.F3.0F38.W0 39 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovdb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovdb<T, U>,

VPMOVDB instruction

InstructionOpcodeCPUID
VPMOVDB xmm1/m32 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 31 /rAVX512VL AVX512F
VPMOVDB xmm1/m64 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 31 /rAVX512VL AVX512F
VPMOVDB xmm1/m128 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 31 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovdw<T, U>,

VPMOVDW instruction

InstructionOpcodeCPUID
VPMOVDW xmm1/m64 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 33 /rAVX512VL AVX512F
VPMOVDW xmm1/m128 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 33 /rAVX512VL AVX512F
VPMOVDW ymm1/m256 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 33 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovm2b<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovm2b<T, U>,

VPMOVM2B instruction

InstructionOpcodeCPUID
VPMOVM2B xmm1, k1EVEX.128.F3.0F38.W0 28 /rAVX512VL AVX512BW
VPMOVM2B ymm1, k1EVEX.256.F3.0F38.W0 28 /rAVX512VL AVX512BW
VPMOVM2B zmm1, k1EVEX.512.F3.0F38.W0 28 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovm2d<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovm2d<T, U>,

VPMOVM2D instruction

InstructionOpcodeCPUID
VPMOVM2D xmm1, k1EVEX.128.F3.0F38.W0 38 /rAVX512VL AVX512DQ
VPMOVM2D ymm1, k1EVEX.256.F3.0F38.W0 38 /rAVX512VL AVX512DQ
VPMOVM2D zmm1, k1EVEX.512.F3.0F38.W0 38 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovm2q<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovm2q<T, U>,

VPMOVM2Q instruction

InstructionOpcodeCPUID
VPMOVM2Q xmm1, k1EVEX.128.F3.0F38.W1 38 /rAVX512VL AVX512DQ
VPMOVM2Q ymm1, k1EVEX.256.F3.0F38.W1 38 /rAVX512VL AVX512DQ
VPMOVM2Q zmm1, k1EVEX.512.F3.0F38.W1 38 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovm2w<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovm2w<T, U>,

VPMOVM2W instruction

InstructionOpcodeCPUID
VPMOVM2W xmm1, k1EVEX.128.F3.0F38.W1 28 /rAVX512VL AVX512BW
VPMOVM2W ymm1, k1EVEX.256.F3.0F38.W1 28 /rAVX512VL AVX512BW
VPMOVM2W zmm1, k1EVEX.512.F3.0F38.W1 28 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovmskb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovmskb<T, U>,

VPMOVMSKB instruction

InstructionOpcodeCPUID
VPMOVMSKB r32, xmm1VEX.128.66.0F.W0 D7 /rAVX
VPMOVMSKB r32, ymm1VEX.256.66.0F.W0 D7 /rAVX2
VPMOVMSKB r64, xmm1VEX.128.66.0F.W1 D7 /rAVX
VPMOVMSKB r64, ymm1VEX.256.66.0F.W1 D7 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovq2m<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovq2m<T, U>,

VPMOVQ2M instruction

InstructionOpcodeCPUID
VPMOVQ2M k1, xmm1EVEX.128.F3.0F38.W1 39 /rAVX512VL AVX512DQ
VPMOVQ2M k1, ymm1EVEX.256.F3.0F38.W1 39 /rAVX512VL AVX512DQ
VPMOVQ2M k1, zmm1EVEX.512.F3.0F38.W1 39 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovqb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovqb<T, U>,

VPMOVQB instruction

InstructionOpcodeCPUID
VPMOVQB xmm1/m16 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 32 /rAVX512VL AVX512F
VPMOVQB xmm1/m32 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 32 /rAVX512VL AVX512F
VPMOVQB xmm1/m64 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 32 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovqd<T, U>,

VPMOVQD instruction

InstructionOpcodeCPUID
VPMOVQD xmm1/m64 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 35 /rAVX512VL AVX512F
VPMOVQD xmm1/m128 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 35 /rAVX512VL AVX512F
VPMOVQD ymm1/m256 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 35 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovqw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovqw<T, U>,

VPMOVQW instruction

InstructionOpcodeCPUID
VPMOVQW xmm1/m32 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 34 /rAVX512VL AVX512F
VPMOVQW xmm1/m64 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 34 /rAVX512VL AVX512F
VPMOVQW xmm1/m128 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 34 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsdb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsdb<T, U>,

VPMOVSDB instruction

InstructionOpcodeCPUID
VPMOVSDB xmm1/m32 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 21 /rAVX512VL AVX512F
VPMOVSDB xmm1/m64 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 21 /rAVX512VL AVX512F
VPMOVSDB xmm1/m128 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 21 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsdw<T, U>,

VPMOVSDW instruction

InstructionOpcodeCPUID
VPMOVSDW xmm1/m64 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 23 /rAVX512VL AVX512F
VPMOVSDW xmm1/m128 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 23 /rAVX512VL AVX512F
VPMOVSDW ymm1/m256 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 23 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsqb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsqb<T, U>,

VPMOVSQB instruction

InstructionOpcodeCPUID
VPMOVSQB xmm1/m16 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 22 /rAVX512VL AVX512F
VPMOVSQB xmm1/m32 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 22 /rAVX512VL AVX512F
VPMOVSQB xmm1/m64 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 22 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsqd<T, U>,

VPMOVSQD instruction

InstructionOpcodeCPUID
VPMOVSQD xmm1/m64 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 25 /rAVX512VL AVX512F
VPMOVSQD xmm1/m128 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 25 /rAVX512VL AVX512F
VPMOVSQD ymm1/m256 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 25 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsqw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsqw<T, U>,

VPMOVSQW instruction

InstructionOpcodeCPUID
VPMOVSQW xmm1/m32 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 24 /rAVX512VL AVX512F
VPMOVSQW xmm1/m64 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 24 /rAVX512VL AVX512F
VPMOVSQW xmm1/m128 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 24 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovswb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovswb<T, U>,

VPMOVSWB instruction

InstructionOpcodeCPUID
VPMOVSWB xmm1/m64 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 20 /rAVX512VL AVX512BW
VPMOVSWB xmm1/m128 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 20 /rAVX512VL AVX512BW
VPMOVSWB ymm1/m256 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 20 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsxbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsxbd<T, U>,

VPMOVSXBD instruction

InstructionOpcodeCPUID
VPMOVSXBD xmm1, xmm2/m32VEX.128.66.0F38.WIG 21 /rAVX
VPMOVSXBD ymm1, xmm2/m64VEX.256.66.0F38.WIG 21 /rAVX2
VPMOVSXBD xmm1 {k1}{z}, xmm2/m32EVEX.128.66.0F38.WIG 21 /rAVX512VL AVX512F
VPMOVSXBD ymm1 {k1}{z}, xmm2/m64EVEX.256.66.0F38.WIG 21 /rAVX512VL AVX512F
VPMOVSXBD zmm1 {k1}{z}, xmm2/m128EVEX.512.66.0F38.WIG 21 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsxbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsxbq<T, U>,

VPMOVSXBQ instruction

InstructionOpcodeCPUID
VPMOVSXBQ xmm1, xmm2/m16VEX.128.66.0F38.WIG 22 /rAVX
VPMOVSXBQ ymm1, xmm2/m32VEX.256.66.0F38.WIG 22 /rAVX2
VPMOVSXBQ xmm1 {k1}{z}, xmm2/m16EVEX.128.66.0F38.WIG 22 /rAVX512VL AVX512F
VPMOVSXBQ ymm1 {k1}{z}, xmm2/m32EVEX.256.66.0F38.WIG 22 /rAVX512VL AVX512F
VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64EVEX.512.66.0F38.WIG 22 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsxbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsxbw<T, U>,

VPMOVSXBW instruction

InstructionOpcodeCPUID
VPMOVSXBW xmm1, xmm2/m64VEX.128.66.0F38.WIG 20 /rAVX
VPMOVSXBW ymm1, xmm2/m128VEX.256.66.0F38.WIG 20 /rAVX2
VPMOVSXBW xmm1 {k1}{z}, xmm2/m64EVEX.128.66.0F38.WIG 20 /rAVX512VL AVX512BW
VPMOVSXBW ymm1 {k1}{z}, xmm2/m128EVEX.256.66.0F38.WIG 20 /rAVX512VL AVX512BW
VPMOVSXBW zmm1 {k1}{z}, ymm2/m256EVEX.512.66.0F38.WIG 20 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsxdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsxdq<T, U>,

VPMOVSXDQ instruction

InstructionOpcodeCPUID
VPMOVSXDQ xmm1, xmm2/m64VEX.128.66.0F38.WIG 25 /rAVX
VPMOVSXDQ ymm1, xmm2/m128VEX.256.66.0F38.WIG 25 /rAVX2
VPMOVSXDQ xmm1 {k1}{z}, xmm2/m64EVEX.128.66.0F38.W0 25 /rAVX512VL AVX512F
VPMOVSXDQ ymm1 {k1}{z}, xmm2/m128EVEX.256.66.0F38.W0 25 /rAVX512VL AVX512F
VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256EVEX.512.66.0F38.W0 25 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsxwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsxwd<T, U>,

VPMOVSXWD instruction

InstructionOpcodeCPUID
VPMOVSXWD xmm1, xmm2/m64VEX.128.66.0F38.WIG 23 /rAVX
VPMOVSXWD ymm1, xmm2/m128VEX.256.66.0F38.WIG 23 /rAVX2
VPMOVSXWD xmm1 {k1}{z}, xmm2/m64EVEX.128.66.0F38.WIG 23 /rAVX512VL AVX512F
VPMOVSXWD ymm1 {k1}{z}, xmm2/m128EVEX.256.66.0F38.WIG 23 /rAVX512VL AVX512F
VPMOVSXWD zmm1 {k1}{z}, ymm2/m256EVEX.512.66.0F38.WIG 23 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovsxwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovsxwq<T, U>,

VPMOVSXWQ instruction

InstructionOpcodeCPUID
VPMOVSXWQ xmm1, xmm2/m32VEX.128.66.0F38.WIG 24 /rAVX
VPMOVSXWQ ymm1, xmm2/m64VEX.256.66.0F38.WIG 24 /rAVX2
VPMOVSXWQ xmm1 {k1}{z}, xmm2/m32EVEX.128.66.0F38.WIG 24 /rAVX512VL AVX512F
VPMOVSXWQ ymm1 {k1}{z}, xmm2/m64EVEX.256.66.0F38.WIG 24 /rAVX512VL AVX512F
VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128EVEX.512.66.0F38.WIG 24 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovusdb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovusdb<T, U>,

VPMOVUSDB instruction

InstructionOpcodeCPUID
VPMOVUSDB xmm1/m32 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 11 /rAVX512VL AVX512F
VPMOVUSDB xmm1/m64 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 11 /rAVX512VL AVX512F
VPMOVUSDB xmm1/m128 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 11 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovusdw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovusdw<T, U>,

VPMOVUSDW instruction

InstructionOpcodeCPUID
VPMOVUSDW xmm1/m64 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 13 /rAVX512VL AVX512F
VPMOVUSDW xmm1/m128 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 13 /rAVX512VL AVX512F
VPMOVUSDW ymm1/m256 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 13 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovusqb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovusqb<T, U>,

VPMOVUSQB instruction

InstructionOpcodeCPUID
VPMOVUSQB xmm1/m16 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 12 /rAVX512VL AVX512F
VPMOVUSQB xmm1/m32 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 12 /rAVX512VL AVX512F
VPMOVUSQB xmm1/m64 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 12 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovusqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovusqd<T, U>,

VPMOVUSQD instruction

InstructionOpcodeCPUID
VPMOVUSQD xmm1/m64 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 15 /rAVX512VL AVX512F
VPMOVUSQD xmm1/m128 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 15 /rAVX512VL AVX512F
VPMOVUSQD ymm1/m256 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 15 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovusqw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovusqw<T, U>,

VPMOVUSQW instruction

InstructionOpcodeCPUID
VPMOVUSQW xmm1/m32 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 14 /rAVX512VL AVX512F
VPMOVUSQW xmm1/m64 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 14 /rAVX512VL AVX512F
VPMOVUSQW xmm1/m128 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 14 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovuswb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovuswb<T, U>,

VPMOVUSWB instruction

InstructionOpcodeCPUID
VPMOVUSWB xmm1/m64 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 10 /rAVX512VL AVX512BW
VPMOVUSWB xmm1/m128 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 10 /rAVX512VL AVX512BW
VPMOVUSWB ymm1/m256 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 10 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovw2m<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovw2m<T, U>,

VPMOVW2M instruction

InstructionOpcodeCPUID
VPMOVW2M k1, xmm1EVEX.128.F3.0F38.W1 29 /rAVX512VL AVX512BW
VPMOVW2M k1, ymm1EVEX.256.F3.0F38.W1 29 /rAVX512VL AVX512BW
VPMOVW2M k1, zmm1EVEX.512.F3.0F38.W1 29 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovwb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovwb<T, U>,

VPMOVWB instruction

InstructionOpcodeCPUID
VPMOVWB xmm1/m64 {k1}{z}, xmm2EVEX.128.F3.0F38.W0 30 /rAVX512VL AVX512BW
VPMOVWB xmm1/m128 {k1}{z}, ymm2EVEX.256.F3.0F38.W0 30 /rAVX512VL AVX512BW
VPMOVWB ymm1/m256 {k1}{z}, zmm2EVEX.512.F3.0F38.W0 30 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovzxbd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovzxbd<T, U>,

VPMOVZXBD instruction

InstructionOpcodeCPUID
VPMOVZXBD xmm1, xmm2/m32VEX.128.66.0F38.WIG 31 /rAVX
VPMOVZXBD ymm1, xmm2/m64VEX.256.66.0F38.WIG 31 /rAVX2
VPMOVZXBD xmm1 {k1}{z}, xmm2/m32EVEX.128.66.0F38.WIG 31 /rAVX512VL AVX512F
VPMOVZXBD ymm1 {k1}{z}, xmm2/m64EVEX.256.66.0F38.WIG 31 /rAVX512VL AVX512F
VPMOVZXBD zmm1 {k1}{z}, xmm2/m128EVEX.512.66.0F38.WIG 31 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovzxbq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovzxbq<T, U>,

VPMOVZXBQ instruction

InstructionOpcodeCPUID
VPMOVZXBQ xmm1, xmm2/m16VEX.128.66.0F38.WIG 32 /rAVX
VPMOVZXBQ ymm1, xmm2/m32VEX.256.66.0F38.WIG 32 /rAVX2
VPMOVZXBQ xmm1 {k1}{z}, xmm2/m16EVEX.128.66.0F38.WIG 32 /rAVX512VL AVX512F
VPMOVZXBQ ymm1 {k1}{z}, xmm2/m32EVEX.256.66.0F38.WIG 32 /rAVX512VL AVX512F
VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64EVEX.512.66.0F38.WIG 32 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovzxbw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovzxbw<T, U>,

VPMOVZXBW instruction

InstructionOpcodeCPUID
VPMOVZXBW xmm1, xmm2/m64VEX.128.66.0F38.WIG 30 /rAVX
VPMOVZXBW ymm1, xmm2/m128VEX.256.66.0F38.WIG 30 /rAVX2
VPMOVZXBW xmm1 {k1}{z}, xmm2/m64EVEX.128.66.0F38.WIG 30 /rAVX512VL AVX512BW
VPMOVZXBW ymm1 {k1}{z}, xmm2/m128EVEX.256.66.0F38.WIG 30 /rAVX512VL AVX512BW
VPMOVZXBW zmm1 {k1}{z}, ymm2/m256EVEX.512.66.0F38.WIG 30 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovzxdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovzxdq<T, U>,

VPMOVZXDQ instruction

InstructionOpcodeCPUID
VPMOVZXDQ xmm1, xmm2/m64VEX.128.66.0F38.WIG 35 /rAVX
VPMOVZXDQ ymm1, xmm2/m128VEX.256.66.0F38.WIG 35 /rAVX2
VPMOVZXDQ xmm1 {k1}{z}, xmm2/m64EVEX.128.66.0F38.W0 35 /rAVX512VL AVX512F
VPMOVZXDQ ymm1 {k1}{z}, xmm2/m128EVEX.256.66.0F38.W0 35 /rAVX512VL AVX512F
VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256EVEX.512.66.0F38.W0 35 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovzxwd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovzxwd<T, U>,

VPMOVZXWD instruction

InstructionOpcodeCPUID
VPMOVZXWD xmm1, xmm2/m64VEX.128.66.0F38.WIG 33 /rAVX
VPMOVZXWD ymm1, xmm2/m128VEX.256.66.0F38.WIG 33 /rAVX2
VPMOVZXWD xmm1 {k1}{z}, xmm2/m64EVEX.128.66.0F38.WIG 33 /rAVX512VL AVX512F
VPMOVZXWD ymm1 {k1}{z}, xmm2/m128EVEX.256.66.0F38.WIG 33 /rAVX512VL AVX512F
VPMOVZXWD zmm1 {k1}{z}, ymm2/m256EVEX.512.66.0F38.WIG 33 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmovzxwq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpmovzxwq<T, U>,

VPMOVZXWQ instruction

InstructionOpcodeCPUID
VPMOVZXWQ xmm1, xmm2/m32VEX.128.66.0F38.WIG 34 /rAVX
VPMOVZXWQ ymm1, xmm2/m64VEX.256.66.0F38.WIG 34 /rAVX2
VPMOVZXWQ xmm1 {k1}{z}, xmm2/m32EVEX.128.66.0F38.WIG 34 /rAVX512VL AVX512F
VPMOVZXWQ ymm1 {k1}{z}, xmm2/m64EVEX.256.66.0F38.WIG 34 /rAVX512VL AVX512F
VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128EVEX.512.66.0F38.WIG 34 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpmuldq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmuldq<T, U, V>,

VPMULDQ instruction

InstructionOpcodeCPUID
VPMULDQ xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 28 /rAVX
VPMULDQ ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 28 /rAVX2
VPMULDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 28 /rAVX512VL AVX512F
VPMULDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 28 /rAVX512VL AVX512F
VPMULDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 28 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmulhrsw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmulhrsw<T, U, V>,

VPMULHRSW instruction

InstructionOpcodeCPUID
VPMULHRSW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 0B /rAVX
VPMULHRSW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 0B /rAVX2
VPMULHRSW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.WIG 0B /rAVX512VL AVX512BW
VPMULHRSW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.WIG 0B /rAVX512VL AVX512BW
VPMULHRSW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.WIG 0B /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmulhuw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmulhuw<T, U, V>,

VPMULHUW instruction

InstructionOpcodeCPUID
VPMULHUW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG E4 /rAVX
VPMULHUW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG E4 /rAVX2
VPMULHUW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG E4 /rAVX512VL AVX512BW
VPMULHUW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG E4 /rAVX512VL AVX512BW
VPMULHUW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG E4 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmulhw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmulhw<T, U, V>,

VPMULHW instruction

InstructionOpcodeCPUID
VPMULHW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG E5 /rAVX
VPMULHW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG E5 /rAVX2
VPMULHW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG E5 /rAVX512VL AVX512BW
VPMULHW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG E5 /rAVX512VL AVX512BW
VPMULHW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG E5 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmulld<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmulld<T, U, V>,

VPMULLD instruction

InstructionOpcodeCPUID
VPMULLD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 40 /rAVX
VPMULLD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 40 /rAVX2
VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 40 /rAVX512VL AVX512F
VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 40 /rAVX512VL AVX512F
VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 40 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmullq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmullq<T, U, V>,

VPMULLQ instruction

InstructionOpcodeCPUID
VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 40 /rAVX512VL AVX512DQ
VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 40 /rAVX512VL AVX512DQ
VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 40 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmullw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmullw<T, U, V>,

VPMULLW instruction

InstructionOpcodeCPUID
VPMULLW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG D5 /rAVX
VPMULLW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG D5 /rAVX2
VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG D5 /rAVX512VL AVX512BW
VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG D5 /rAVX512VL AVX512BW
VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG D5 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpmultishiftqb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmultishiftqb<T, U, V>,

VPMULTISHIFTQB instruction

InstructionOpcodeCPUID
VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 83 /rAVX512VL AVX512_VBMI
VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 83 /rAVX512VL AVX512_VBMI
VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 83 /rAVX512_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
Source

pub fn vpmuludq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpmuludq<T, U, V>,

VPMULUDQ instruction

InstructionOpcodeCPUID
VPMULUDQ xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG F4 /rAVX
VPMULUDQ ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG F4 /rAVX2
VPMULUDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 F4 /rAVX512VL AVX512F
VPMULUDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 F4 /rAVX512VL AVX512F
VPMULUDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 F4 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpopcntb<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpopcntb<T, U>,

VPOPCNTB instruction

InstructionOpcodeCPUID
VPOPCNTB xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.W0 54 /rAVX512VL AVX512_BITALG
VPOPCNTB ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.W0 54 /rAVX512VL AVX512_BITALG
VPOPCNTB zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.W0 54 /rAVX512_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
Source

pub fn vpopcntd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpopcntd<T, U>,

VPOPCNTD instruction

InstructionOpcodeCPUID
VPOPCNTD xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.0F38.W0 55 /rAVX512VL AVX512_VPOPCNTDQ
VPOPCNTD ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.0F38.W0 55 /rAVX512VL AVX512_VPOPCNTDQ
VPOPCNTD zmm1 {k1}{z}, zmm2/m512/m32bcstEVEX.512.66.0F38.W0 55 /rAVX512_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
Source

pub fn vpopcntq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpopcntq<T, U>,

VPOPCNTQ instruction

InstructionOpcodeCPUID
VPOPCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F38.W1 55 /rAVX512VL AVX512_VPOPCNTDQ
VPOPCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F38.W1 55 /rAVX512VL AVX512_VPOPCNTDQ
VPOPCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcstEVEX.512.66.0F38.W1 55 /rAVX512_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
Source

pub fn vpopcntw<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpopcntw<T, U>,

VPOPCNTW instruction

InstructionOpcodeCPUID
VPOPCNTW xmm1 {k1}{z}, xmm2/m128EVEX.128.66.0F38.W1 54 /rAVX512VL AVX512_BITALG
VPOPCNTW ymm1 {k1}{z}, ymm2/m256EVEX.256.66.0F38.W1 54 /rAVX512VL AVX512_BITALG
VPOPCNTW zmm1 {k1}{z}, zmm2/m512EVEX.512.66.0F38.W1 54 /rAVX512_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
Source

pub fn vpor<T, U, V>(&mut self, op0: T, op1: U, op2: V) -> Result<(), IcedError>
where Self: CodeAsmVpor<T, U, V>,

VPOR instruction

InstructionOpcodeCPUID
VPOR xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG EB /rAVX
VPOR ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG EB /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpord<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpord<T, U, V>,

VPORD instruction

InstructionOpcodeCPUID
VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 EB /rAVX512VL AVX512F
VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 EB /rAVX512VL AVX512F
VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 EB /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vporq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVporq<T, U, V>,

VPORQ instruction

InstructionOpcodeCPUID
VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 EB /rAVX512VL AVX512F
VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 EB /rAVX512VL AVX512F
VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 EB /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPPERM xmm1, xmm2, xmm3/m128, xmm4XOP.128.X8.W0 A3 /r /is4XOP
VPPERM xmm1, xmm2, xmm3, xmm4/m128XOP.128.X8.W1 A3 /r /is4XOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vprold<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprold<T, U, V>,

VPROLD instruction

InstructionOpcodeCPUID
VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F.W0 72 /1 ibAVX512VL AVX512F
VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F.W0 72 /1 ibAVX512VL AVX512F
VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8EVEX.512.66.0F.W0 72 /1 ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprolq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprolq<T, U, V>,

VPROLQ instruction

InstructionOpcodeCPUID
VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F.W1 72 /1 ibAVX512VL AVX512F
VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F.W1 72 /1 ibAVX512VL AVX512F
VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F.W1 72 /1 ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprolvd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprolvd<T, U, V>,

VPROLVD instruction

InstructionOpcodeCPUID
VPROLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 15 /rAVX512VL AVX512F
VPROLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 15 /rAVX512VL AVX512F
VPROLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 15 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprolvq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprolvq<T, U, V>,

VPROLVQ instruction

InstructionOpcodeCPUID
VPROLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 15 /rAVX512VL AVX512F
VPROLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 15 /rAVX512VL AVX512F
VPROLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 15 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprord<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprord<T, U, V>,

VPRORD instruction

InstructionOpcodeCPUID
VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F.W0 72 /0 ibAVX512VL AVX512F
VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F.W0 72 /0 ibAVX512VL AVX512F
VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8EVEX.512.66.0F.W0 72 /0 ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprorq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprorq<T, U, V>,

VPRORQ instruction

InstructionOpcodeCPUID
VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F.W1 72 /0 ibAVX512VL AVX512F
VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F.W1 72 /0 ibAVX512VL AVX512F
VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F.W1 72 /0 ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprorvd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprorvd<T, U, V>,

VPRORVD instruction

InstructionOpcodeCPUID
VPRORVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 14 /rAVX512VL AVX512F
VPRORVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 14 /rAVX512VL AVX512F
VPRORVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 14 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprorvq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprorvq<T, U, V>,

VPRORVQ instruction

InstructionOpcodeCPUID
VPRORVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 14 /rAVX512VL AVX512F
VPRORVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 14 /rAVX512VL AVX512F
VPRORVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 14 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprotb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprotb<T, U, V>,

VPROTB instruction

InstructionOpcodeCPUID
VPROTB xmm1, xmm2/m128, imm8XOP.128.X8.W0 C0 /r ibXOP
VPROTB xmm1, xmm2/m128, xmm3XOP.128.X9.W0 90 /rXOP
VPROTB xmm1, xmm2, xmm3/m128XOP.128.X9.W1 90 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprotd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprotd<T, U, V>,

VPROTD instruction

InstructionOpcodeCPUID
VPROTD xmm1, xmm2/m128, imm8XOP.128.X8.W0 C2 /r ibXOP
VPROTD xmm1, xmm2/m128, xmm3XOP.128.X9.W0 92 /rXOP
VPROTD xmm1, xmm2, xmm3/m128XOP.128.X9.W1 92 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprotq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprotq<T, U, V>,

VPROTQ instruction

InstructionOpcodeCPUID
VPROTQ xmm1, xmm2/m128, imm8XOP.128.X8.W0 C3 /r ibXOP
VPROTQ xmm1, xmm2/m128, xmm3XOP.128.X9.W0 93 /rXOP
VPROTQ xmm1, xmm2, xmm3/m128XOP.128.X9.W1 93 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vprotw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVprotw<T, U, V>,

VPROTW instruction

InstructionOpcodeCPUID
VPROTW xmm1, xmm2/m128, imm8XOP.128.X8.W0 C1 /r ibXOP
VPROTW xmm1, xmm2/m128, xmm3XOP.128.X9.W0 91 /rXOP
VPROTW xmm1, xmm2, xmm3/m128XOP.128.X9.W1 91 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsadbw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsadbw<T, U, V>,

VPSADBW instruction

InstructionOpcodeCPUID
VPSADBW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG F6 /rAVX
VPSADBW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG F6 /rAVX2
VPSADBW xmm1, xmm2, xmm3/m128EVEX.128.66.0F.WIG F6 /rAVX512VL AVX512BW
VPSADBW ymm1, ymm2, ymm3/m256EVEX.256.66.0F.WIG F6 /rAVX512VL AVX512BW
VPSADBW zmm1, zmm2, zmm3/m512EVEX.512.66.0F.WIG F6 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpscatterdd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpscatterdd<T, U>,

VPSCATTERDD instruction

InstructionOpcodeCPUID
VPSCATTERDD vm32x {k1}, xmm1EVEX.128.66.0F38.W0 A0 /vsibAVX512VL AVX512F
VPSCATTERDD vm32y {k1}, ymm1EVEX.256.66.0F38.W0 A0 /vsibAVX512VL AVX512F
VPSCATTERDD vm32z {k1}, zmm1EVEX.512.66.0F38.W0 A0 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpscatterdq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpscatterdq<T, U>,

VPSCATTERDQ instruction

InstructionOpcodeCPUID
VPSCATTERDQ vm32x {k1}, xmm1EVEX.128.66.0F38.W1 A0 /vsibAVX512VL AVX512F
VPSCATTERDQ vm32x {k1}, ymm1EVEX.256.66.0F38.W1 A0 /vsibAVX512VL AVX512F
VPSCATTERDQ vm32y {k1}, zmm1EVEX.512.66.0F38.W1 A0 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpscatterqd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpscatterqd<T, U>,

VPSCATTERQD instruction

InstructionOpcodeCPUID
VPSCATTERQD vm64x {k1}, xmm1EVEX.128.66.0F38.W0 A1 /vsibAVX512VL AVX512F
VPSCATTERQD vm64y {k1}, xmm1EVEX.256.66.0F38.W0 A1 /vsibAVX512VL AVX512F
VPSCATTERQD vm64z {k1}, ymm1EVEX.512.66.0F38.W0 A1 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpscatterqq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVpscatterqq<T, U>,

VPSCATTERQQ instruction

InstructionOpcodeCPUID
VPSCATTERQQ vm64x {k1}, xmm1EVEX.128.66.0F38.W1 A1 /vsibAVX512VL AVX512F
VPSCATTERQQ vm64y {k1}, ymm1EVEX.256.66.0F38.W1 A1 /vsibAVX512VL AVX512F
VPSCATTERQQ vm64z {k1}, zmm1EVEX.512.66.0F38.W1 A1 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vpshab<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshab<T, U, V>,

VPSHAB instruction

InstructionOpcodeCPUID
VPSHAB xmm1, xmm2/m128, xmm3XOP.128.X9.W0 98 /rXOP
VPSHAB xmm1, xmm2, xmm3/m128XOP.128.X9.W1 98 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpshad<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshad<T, U, V>,

VPSHAD instruction

InstructionOpcodeCPUID
VPSHAD xmm1, xmm2/m128, xmm3XOP.128.X9.W0 9A /rXOP
VPSHAD xmm1, xmm2, xmm3/m128XOP.128.X9.W1 9A /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpshaq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshaq<T, U, V>,

VPSHAQ instruction

InstructionOpcodeCPUID
VPSHAQ xmm1, xmm2/m128, xmm3XOP.128.X9.W0 9B /rXOP
VPSHAQ xmm1, xmm2, xmm3/m128XOP.128.X9.W1 9B /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpshaw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshaw<T, U, V>,

VPSHAW instruction

InstructionOpcodeCPUID
VPSHAW xmm1, xmm2/m128, xmm3XOP.128.X9.W0 99 /rXOP
VPSHAW xmm1, xmm2, xmm3/m128XOP.128.X9.W1 99 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpshlb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshlb<T, U, V>,

VPSHLB instruction

InstructionOpcodeCPUID
VPSHLB xmm1, xmm2/m128, xmm3XOP.128.X9.W0 94 /rXOP
VPSHLB xmm1, xmm2, xmm3/m128XOP.128.X9.W1 94 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpshld<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshld<T, U, V>,

VPSHLD instruction

InstructionOpcodeCPUID
VPSHLD xmm1, xmm2/m128, xmm3XOP.128.X9.W0 96 /rXOP
VPSHLD xmm1, xmm2, xmm3/m128XOP.128.X9.W1 96 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPSHLDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 71 /r ibAVX512VL AVX512_VBMI2
VPSHLDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 71 /r ibAVX512VL AVX512_VBMI2
VPSHLDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 71 /r ibAVX512_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
Source

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

InstructionOpcodeCPUID
VPSHLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 71 /r ibAVX512VL AVX512_VBMI2
VPSHLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 71 /r ibAVX512VL AVX512_VBMI2
VPSHLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 71 /r ibAVX512_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
Source

pub fn vpshldvd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshldvd<T, U, V>,

VPSHLDVD instruction

InstructionOpcodeCPUID
VPSHLDVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 71 /rAVX512VL AVX512_VBMI2
VPSHLDVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 71 /rAVX512VL AVX512_VBMI2
VPSHLDVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 71 /rAVX512_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
Source

pub fn vpshldvq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshldvq<T, U, V>,

VPSHLDVQ instruction

InstructionOpcodeCPUID
VPSHLDVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 71 /rAVX512VL AVX512_VBMI2
VPSHLDVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 71 /rAVX512VL AVX512_VBMI2
VPSHLDVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 71 /rAVX512_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
Source

pub fn vpshldvw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshldvw<T, U, V>,

VPSHLDVW instruction

InstructionOpcodeCPUID
VPSHLDVW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 70 /rAVX512VL AVX512_VBMI2
VPSHLDVW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 70 /rAVX512VL AVX512_VBMI2
VPSHLDVW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 70 /rAVX512_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
Source

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

InstructionOpcodeCPUID
VPSHLDW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 70 /r ibAVX512VL AVX512_VBMI2
VPSHLDW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 70 /r ibAVX512VL AVX512_VBMI2
VPSHLDW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 70 /r ibAVX512_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
Source

pub fn vpshlq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshlq<T, U, V>,

VPSHLQ instruction

InstructionOpcodeCPUID
VPSHLQ xmm1, xmm2/m128, xmm3XOP.128.X9.W0 97 /rXOP
VPSHLQ xmm1, xmm2, xmm3/m128XOP.128.X9.W1 97 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpshlw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshlw<T, U, V>,

VPSHLW instruction

InstructionOpcodeCPUID
VPSHLW xmm1, xmm2/m128, xmm3XOP.128.X9.W0 95 /rXOP
VPSHLW xmm1, xmm2, xmm3/m128XOP.128.X9.W1 95 /rXOP
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPSHRDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 73 /r ibAVX512VL AVX512_VBMI2
VPSHRDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 73 /r ibAVX512VL AVX512_VBMI2
VPSHRDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 73 /r ibAVX512_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
Source

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

InstructionOpcodeCPUID
VPSHRDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 73 /r ibAVX512VL AVX512_VBMI2
VPSHRDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 73 /r ibAVX512VL AVX512_VBMI2
VPSHRDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 73 /r ibAVX512_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
Source

pub fn vpshrdvd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshrdvd<T, U, V>,

VPSHRDVD instruction

InstructionOpcodeCPUID
VPSHRDVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 73 /rAVX512VL AVX512_VBMI2
VPSHRDVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 73 /rAVX512VL AVX512_VBMI2
VPSHRDVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 73 /rAVX512_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
Source

pub fn vpshrdvq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshrdvq<T, U, V>,

VPSHRDVQ instruction

InstructionOpcodeCPUID
VPSHRDVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 73 /rAVX512VL AVX512_VBMI2
VPSHRDVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 73 /rAVX512VL AVX512_VBMI2
VPSHRDVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 73 /rAVX512_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
Source

pub fn vpshrdvw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshrdvw<T, U, V>,

VPSHRDVW instruction

InstructionOpcodeCPUID
VPSHRDVW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 72 /rAVX512VL AVX512_VBMI2
VPSHRDVW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 72 /rAVX512VL AVX512_VBMI2
VPSHRDVW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 72 /rAVX512_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
Source

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

InstructionOpcodeCPUID
VPSHRDW xmm1 {k1}{z}, xmm2, xmm3/m128, imm8EVEX.128.66.0F3A.W1 72 /r ibAVX512VL AVX512_VBMI2
VPSHRDW ymm1 {k1}{z}, ymm2, ymm3/m256, imm8EVEX.256.66.0F3A.W1 72 /r ibAVX512VL AVX512_VBMI2
VPSHRDW zmm1 {k1}{z}, zmm2, zmm3/m512, imm8EVEX.512.66.0F3A.W1 72 /r ibAVX512_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
Source

pub fn vpshufb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshufb<T, U, V>,

VPSHUFB instruction

InstructionOpcodeCPUID
VPSHUFB xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 00 /rAVX
VPSHUFB ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 00 /rAVX2
VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.WIG 00 /rAVX512VL AVX512BW
VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.WIG 00 /rAVX512VL AVX512BW
VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.WIG 00 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpshufbitqmb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshufbitqmb<T, U, V>,

VPSHUFBITQMB instruction

InstructionOpcodeCPUID
VPSHUFBITQMB k1 {k2}, xmm2, xmm3/m128EVEX.128.66.0F38.W0 8F /rAVX512VL AVX512_BITALG
VPSHUFBITQMB k1 {k2}, ymm2, ymm3/m256EVEX.256.66.0F38.W0 8F /rAVX512VL AVX512_BITALG
VPSHUFBITQMB k1 {k2}, zmm2, zmm3/m512EVEX.512.66.0F38.W0 8F /rAVX512_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
Source

pub fn vpshufd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshufd<T, U, V>,

VPSHUFD instruction

InstructionOpcodeCPUID
VPSHUFD xmm1, xmm2/m128, imm8VEX.128.66.0F.WIG 70 /r ibAVX
VPSHUFD ymm1, ymm2/m256, imm8VEX.256.66.0F.WIG 70 /r ibAVX2
VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F.W0 70 /r ibAVX512VL AVX512F
VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F.W0 70 /r ibAVX512VL AVX512F
VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8EVEX.512.66.0F.W0 70 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpshufhw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshufhw<T, U, V>,

VPSHUFHW instruction

InstructionOpcodeCPUID
VPSHUFHW xmm1, xmm2/m128, imm8VEX.128.F3.0F.WIG 70 /r ibAVX
VPSHUFHW ymm1, ymm2/m256, imm8VEX.256.F3.0F.WIG 70 /r ibAVX2
VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8EVEX.128.F3.0F.WIG 70 /r ibAVX512VL AVX512BW
VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8EVEX.256.F3.0F.WIG 70 /r ibAVX512VL AVX512BW
VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8EVEX.512.F3.0F.WIG 70 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpshuflw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpshuflw<T, U, V>,

VPSHUFLW instruction

InstructionOpcodeCPUID
VPSHUFLW xmm1, xmm2/m128, imm8VEX.128.F2.0F.WIG 70 /r ibAVX
VPSHUFLW ymm1, ymm2/m256, imm8VEX.256.F2.0F.WIG 70 /r ibAVX2
VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8EVEX.128.F2.0F.WIG 70 /r ibAVX512VL AVX512BW
VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8EVEX.256.F2.0F.WIG 70 /r ibAVX512VL AVX512BW
VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8EVEX.512.F2.0F.WIG 70 /r ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsignb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsignb<T, U, V>,

VPSIGNB instruction

InstructionOpcodeCPUID
VPSIGNB xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 08 /rAVX
VPSIGNB ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 08 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsignd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsignd<T, U, V>,

VPSIGND instruction

InstructionOpcodeCPUID
VPSIGND xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 0A /rAVX
VPSIGND ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 0A /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsignw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsignw<T, U, V>,

VPSIGNW instruction

InstructionOpcodeCPUID
VPSIGNW xmm1, xmm2, xmm3/m128VEX.128.66.0F38.WIG 09 /rAVX
VPSIGNW ymm1, ymm2, ymm3/m256VEX.256.66.0F38.WIG 09 /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpslld<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpslld<T, U, V>,

VPSLLD instruction

InstructionOpcodeCPUID
VPSLLD xmm1, xmm2, imm8VEX.128.66.0F.WIG 72 /6 ibAVX
VPSLLD ymm1, ymm2, imm8VEX.256.66.0F.WIG 72 /6 ibAVX2
VPSLLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F.W0 72 /6 ibAVX512VL AVX512F
VPSLLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F.W0 72 /6 ibAVX512VL AVX512F
VPSLLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8EVEX.512.66.0F.W0 72 /6 ibAVX512F
VPSLLD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG F2 /rAVX
VPSLLD ymm1, ymm2, xmm3/m128VEX.256.66.0F.WIG F2 /rAVX2
VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.W0 F2 /rAVX512VL AVX512F
VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128EVEX.256.66.0F.W0 F2 /rAVX512VL AVX512F
VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128EVEX.512.66.0F.W0 F2 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpslldq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpslldq<T, U, V>,

VPSLLDQ instruction

InstructionOpcodeCPUID
VPSLLDQ xmm1, xmm2, imm8VEX.128.66.0F.WIG 73 /7 ibAVX
VPSLLDQ ymm1, ymm2, imm8VEX.256.66.0F.WIG 73 /7 ibAVX2
VPSLLDQ xmm1, xmm2/m128, imm8EVEX.128.66.0F.WIG 73 /7 ibAVX512VL AVX512BW
VPSLLDQ ymm1, ymm2/m256, imm8EVEX.256.66.0F.WIG 73 /7 ibAVX512VL AVX512BW
VPSLLDQ zmm1, zmm2/m512, imm8EVEX.512.66.0F.WIG 73 /7 ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsllq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsllq<T, U, V>,

VPSLLQ instruction

InstructionOpcodeCPUID
VPSLLQ xmm1, xmm2, imm8VEX.128.66.0F.WIG 73 /6 ibAVX
VPSLLQ ymm1, ymm2, imm8VEX.256.66.0F.WIG 73 /6 ibAVX2
VPSLLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F.W1 73 /6 ibAVX512VL AVX512F
VPSLLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F.W1 73 /6 ibAVX512VL AVX512F
VPSLLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F.W1 73 /6 ibAVX512F
VPSLLQ xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG F3 /rAVX
VPSLLQ ymm1, ymm2, xmm3/m128VEX.256.66.0F.WIG F3 /rAVX2
VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.W1 F3 /rAVX512VL AVX512F
VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128EVEX.256.66.0F.W1 F3 /rAVX512VL AVX512F
VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128EVEX.512.66.0F.W1 F3 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsllvd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsllvd<T, U, V>,

VPSLLVD instruction

InstructionOpcodeCPUID
VPSLLVD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 47 /rAVX2
VPSLLVD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 47 /rAVX2
VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 47 /rAVX512VL AVX512F
VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 47 /rAVX512VL AVX512F
VPSLLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 47 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsllvq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsllvq<T, U, V>,

VPSLLVQ instruction

InstructionOpcodeCPUID
VPSLLVQ xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 47 /rAVX2
VPSLLVQ ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 47 /rAVX2
VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 47 /rAVX512VL AVX512F
VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 47 /rAVX512VL AVX512F
VPSLLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 47 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsllvw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsllvw<T, U, V>,

VPSLLVW instruction

InstructionOpcodeCPUID
VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 12 /rAVX512VL AVX512BW
VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 12 /rAVX512VL AVX512BW
VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 12 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsllw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsllw<T, U, V>,

VPSLLW instruction

InstructionOpcodeCPUID
VPSLLW xmm1, xmm2, imm8VEX.128.66.0F.WIG 71 /6 ibAVX
VPSLLW ymm1, ymm2, imm8VEX.256.66.0F.WIG 71 /6 ibAVX2
VPSLLW xmm1 {k1}{z}, xmm2/m128, imm8EVEX.128.66.0F.WIG 71 /6 ibAVX512VL AVX512BW
VPSLLW ymm1 {k1}{z}, ymm2/m256, imm8EVEX.256.66.0F.WIG 71 /6 ibAVX512VL AVX512BW
VPSLLW zmm1 {k1}{z}, zmm2/m512, imm8EVEX.512.66.0F.WIG 71 /6 ibAVX512BW
VPSLLW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG F1 /rAVX
VPSLLW ymm1, ymm2, xmm3/m128VEX.256.66.0F.WIG F1 /rAVX2
VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG F1 /rAVX512VL AVX512BW
VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128EVEX.256.66.0F.WIG F1 /rAVX512VL AVX512BW
VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128EVEX.512.66.0F.WIG F1 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsrad<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsrad<T, U, V>,

VPSRAD instruction

InstructionOpcodeCPUID
VPSRAD xmm1, xmm2, imm8VEX.128.66.0F.WIG 72 /4 ibAVX
VPSRAD ymm1, ymm2, imm8VEX.256.66.0F.WIG 72 /4 ibAVX2
VPSRAD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F.W0 72 /4 ibAVX512VL AVX512F
VPSRAD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F.W0 72 /4 ibAVX512VL AVX512F
VPSRAD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8EVEX.512.66.0F.W0 72 /4 ibAVX512F
VPSRAD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG E2 /rAVX
VPSRAD ymm1, ymm2, xmm3/m128VEX.256.66.0F.WIG E2 /rAVX2
VPSRAD xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.W0 E2 /rAVX512VL AVX512F
VPSRAD ymm1 {k1}{z}, ymm2, xmm3/m128EVEX.256.66.0F.W0 E2 /rAVX512VL AVX512F
VPSRAD zmm1 {k1}{z}, zmm2, xmm3/m128EVEX.512.66.0F.W0 E2 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsraq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsraq<T, U, V>,

VPSRAQ instruction

InstructionOpcodeCPUID
VPSRAQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F.W1 72 /4 ibAVX512VL AVX512F
VPSRAQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F.W1 72 /4 ibAVX512VL AVX512F
VPSRAQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F.W1 72 /4 ibAVX512F
VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.W1 E2 /rAVX512VL AVX512F
VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128EVEX.256.66.0F.W1 E2 /rAVX512VL AVX512F
VPSRAQ zmm1 {k1}{z}, zmm2, xmm3/m128EVEX.512.66.0F.W1 E2 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsravd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsravd<T, U, V>,

VPSRAVD instruction

InstructionOpcodeCPUID
VPSRAVD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 46 /rAVX2
VPSRAVD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 46 /rAVX2
VPSRAVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 46 /rAVX512VL AVX512F
VPSRAVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 46 /rAVX512VL AVX512F
VPSRAVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 46 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsravq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsravq<T, U, V>,

VPSRAVQ instruction

InstructionOpcodeCPUID
VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 46 /rAVX512VL AVX512F
VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 46 /rAVX512VL AVX512F
VPSRAVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 46 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsravw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsravw<T, U, V>,

VPSRAVW instruction

InstructionOpcodeCPUID
VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 11 /rAVX512VL AVX512BW
VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 11 /rAVX512VL AVX512BW
VPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 11 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsraw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsraw<T, U, V>,

VPSRAW instruction

InstructionOpcodeCPUID
VPSRAW xmm1, xmm2, imm8VEX.128.66.0F.WIG 71 /4 ibAVX
VPSRAW ymm1, ymm2, imm8VEX.256.66.0F.WIG 71 /4 ibAVX2
VPSRAW xmm1 {k1}{z}, xmm2/m128, imm8EVEX.128.66.0F.WIG 71 /4 ibAVX512VL AVX512BW
VPSRAW ymm1 {k1}{z}, ymm2/m256, imm8EVEX.256.66.0F.WIG 71 /4 ibAVX512VL AVX512BW
VPSRAW zmm1 {k1}{z}, zmm2/m512, imm8EVEX.512.66.0F.WIG 71 /4 ibAVX512BW
VPSRAW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG E1 /rAVX
VPSRAW ymm1, ymm2, xmm3/m128VEX.256.66.0F.WIG E1 /rAVX2
VPSRAW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG E1 /rAVX512VL AVX512BW
VPSRAW ymm1 {k1}{z}, ymm2, xmm3/m128EVEX.256.66.0F.WIG E1 /rAVX512VL AVX512BW
VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128EVEX.512.66.0F.WIG E1 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsrld<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsrld<T, U, V>,

VPSRLD instruction

InstructionOpcodeCPUID
VPSRLD xmm1, xmm2, imm8VEX.128.66.0F.WIG 72 /2 ibAVX
VPSRLD ymm1, ymm2, imm8VEX.256.66.0F.WIG 72 /2 ibAVX2
VPSRLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F.W0 72 /2 ibAVX512VL AVX512F
VPSRLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F.W0 72 /2 ibAVX512VL AVX512F
VPSRLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8EVEX.512.66.0F.W0 72 /2 ibAVX512F
VPSRLD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG D2 /rAVX
VPSRLD ymm1, ymm2, xmm3/m128VEX.256.66.0F.WIG D2 /rAVX2
VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.W0 D2 /rAVX512VL AVX512F
VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128EVEX.256.66.0F.W0 D2 /rAVX512VL AVX512F
VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128EVEX.512.66.0F.W0 D2 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsrldq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsrldq<T, U, V>,

VPSRLDQ instruction

InstructionOpcodeCPUID
VPSRLDQ xmm1, xmm2, imm8VEX.128.66.0F.WIG 73 /3 ibAVX
VPSRLDQ ymm1, ymm2, imm8VEX.256.66.0F.WIG 73 /3 ibAVX2
VPSRLDQ xmm1, xmm2/m128, imm8EVEX.128.66.0F.WIG 73 /3 ibAVX512VL AVX512BW
VPSRLDQ ymm1, ymm2/m256, imm8EVEX.256.66.0F.WIG 73 /3 ibAVX512VL AVX512BW
VPSRLDQ zmm1, zmm2/m512, imm8EVEX.512.66.0F.WIG 73 /3 ibAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsrlq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsrlq<T, U, V>,

VPSRLQ instruction

InstructionOpcodeCPUID
VPSRLQ xmm1, xmm2, imm8VEX.128.66.0F.WIG 73 /2 ibAVX
VPSRLQ ymm1, ymm2, imm8VEX.256.66.0F.WIG 73 /2 ibAVX2
VPSRLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F.W1 73 /2 ibAVX512VL AVX512F
VPSRLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F.W1 73 /2 ibAVX512VL AVX512F
VPSRLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8EVEX.512.66.0F.W1 73 /2 ibAVX512F
VPSRLQ xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG D3 /rAVX
VPSRLQ ymm1, ymm2, xmm3/m128VEX.256.66.0F.WIG D3 /rAVX2
VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.W1 D3 /rAVX512VL AVX512F
VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128EVEX.256.66.0F.W1 D3 /rAVX512VL AVX512F
VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128EVEX.512.66.0F.W1 D3 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsrlvd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsrlvd<T, U, V>,

VPSRLVD instruction

InstructionOpcodeCPUID
VPSRLVD xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 45 /rAVX2
VPSRLVD ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W0 45 /rAVX2
VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 45 /rAVX512VL AVX512F
VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 45 /rAVX512VL AVX512F
VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 45 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsrlvq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsrlvq<T, U, V>,

VPSRLVQ instruction

InstructionOpcodeCPUID
VPSRLVQ xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W1 45 /rAVX2
VPSRLVQ ymm1, ymm2, ymm3/m256VEX.256.66.0F38.W1 45 /rAVX2
VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 45 /rAVX512VL AVX512F
VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 45 /rAVX512VL AVX512F
VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 45 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsrlvw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsrlvw<T, U, V>,

VPSRLVW instruction

InstructionOpcodeCPUID
VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 10 /rAVX512VL AVX512BW
VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 10 /rAVX512VL AVX512BW
VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 10 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsrlw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsrlw<T, U, V>,

VPSRLW instruction

InstructionOpcodeCPUID
VPSRLW xmm1, xmm2, imm8VEX.128.66.0F.WIG 71 /2 ibAVX
VPSRLW ymm1, ymm2, imm8VEX.256.66.0F.WIG 71 /2 ibAVX2
VPSRLW xmm1 {k1}{z}, xmm2/m128, imm8EVEX.128.66.0F.WIG 71 /2 ibAVX512VL AVX512BW
VPSRLW ymm1 {k1}{z}, ymm2/m256, imm8EVEX.256.66.0F.WIG 71 /2 ibAVX512VL AVX512BW
VPSRLW zmm1 {k1}{z}, zmm2/m512, imm8EVEX.512.66.0F.WIG 71 /2 ibAVX512BW
VPSRLW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG D1 /rAVX
VPSRLW ymm1, ymm2, xmm3/m128VEX.256.66.0F.WIG D1 /rAVX2
VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG D1 /rAVX512VL AVX512BW
VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128EVEX.256.66.0F.WIG D1 /rAVX512VL AVX512BW
VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128EVEX.512.66.0F.WIG D1 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsubb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsubb<T, U, V>,

VPSUBB instruction

InstructionOpcodeCPUID
VPSUBB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG F8 /rAVX
VPSUBB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG F8 /rAVX2
VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG F8 /rAVX512VL AVX512BW
VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG F8 /rAVX512VL AVX512BW
VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG F8 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsubd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsubd<T, U, V>,

VPSUBD instruction

InstructionOpcodeCPUID
VPSUBD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG FA /rAVX
VPSUBD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG FA /rAVX2
VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 FA /rAVX512VL AVX512F
VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 FA /rAVX512VL AVX512F
VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 FA /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsubq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsubq<T, U, V>,

VPSUBQ instruction

InstructionOpcodeCPUID
VPSUBQ xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG FB /rAVX
VPSUBQ ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG FB /rAVX2
VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 FB /rAVX512VL AVX512F
VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 FB /rAVX512VL AVX512F
VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 FB /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsubsb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsubsb<T, U, V>,

VPSUBSB instruction

InstructionOpcodeCPUID
VPSUBSB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG E8 /rAVX
VPSUBSB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG E8 /rAVX2
VPSUBSB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG E8 /rAVX512VL AVX512BW
VPSUBSB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG E8 /rAVX512VL AVX512BW
VPSUBSB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG E8 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsubsw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsubsw<T, U, V>,

VPSUBSW instruction

InstructionOpcodeCPUID
VPSUBSW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG E9 /rAVX
VPSUBSW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG E9 /rAVX2
VPSUBSW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG E9 /rAVX512VL AVX512BW
VPSUBSW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG E9 /rAVX512VL AVX512BW
VPSUBSW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG E9 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsubusb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsubusb<T, U, V>,

VPSUBUSB instruction

InstructionOpcodeCPUID
VPSUBUSB xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG D8 /rAVX
VPSUBUSB ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG D8 /rAVX2
VPSUBUSB xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG D8 /rAVX512VL AVX512BW
VPSUBUSB ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG D8 /rAVX512VL AVX512BW
VPSUBUSB zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG D8 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsubusw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsubusw<T, U, V>,

VPSUBUSW instruction

InstructionOpcodeCPUID
VPSUBUSW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG D9 /rAVX
VPSUBUSW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG D9 /rAVX2
VPSUBUSW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG D9 /rAVX512VL AVX512BW
VPSUBUSW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG D9 /rAVX512VL AVX512BW
VPSUBUSW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG D9 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpsubw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpsubw<T, U, V>,

VPSUBW instruction

InstructionOpcodeCPUID
VPSUBW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG F9 /rAVX
VPSUBW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG F9 /rAVX2
VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG F9 /rAVX512VL AVX512BW
VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG F9 /rAVX512VL AVX512BW
VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG F9 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 25 /r ibAVX512VL AVX512F
VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 25 /r ibAVX512VL AVX512F
VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 25 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 25 /r ibAVX512VL AVX512F
VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 25 /r ibAVX512VL AVX512F
VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 25 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vptest<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVptest<T, U>,

VPTEST instruction

InstructionOpcodeCPUID
VPTEST xmm1, xmm2/m128VEX.128.66.0F38.WIG 17 /rAVX
VPTEST ymm1, ymm2/m256VEX.256.66.0F38.WIG 17 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vptestmb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVptestmb<T, U, V>,

VPTESTMB instruction

InstructionOpcodeCPUID
VPTESTMB k2 {k1}, xmm2, xmm3/m128EVEX.128.66.0F38.W0 26 /rAVX512VL AVX512BW
VPTESTMB k2 {k1}, ymm2, ymm3/m256EVEX.256.66.0F38.W0 26 /rAVX512VL AVX512BW
VPTESTMB k2 {k1}, zmm2, zmm3/m512EVEX.512.66.0F38.W0 26 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vptestmd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVptestmd<T, U, V>,

VPTESTMD instruction

InstructionOpcodeCPUID
VPTESTMD k2 {k1}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 27 /rAVX512VL AVX512F
VPTESTMD k2 {k1}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 27 /rAVX512VL AVX512F
VPTESTMD k2 {k1}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F38.W0 27 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vptestmq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVptestmq<T, U, V>,

VPTESTMQ instruction

InstructionOpcodeCPUID
VPTESTMQ k2 {k1}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 27 /rAVX512VL AVX512F
VPTESTMQ k2 {k1}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 27 /rAVX512VL AVX512F
VPTESTMQ k2 {k1}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F38.W1 27 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vptestmw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVptestmw<T, U, V>,

VPTESTMW instruction

InstructionOpcodeCPUID
VPTESTMW k2 {k1}, xmm2, xmm3/m128EVEX.128.66.0F38.W1 26 /rAVX512VL AVX512BW
VPTESTMW k2 {k1}, ymm2, ymm3/m256EVEX.256.66.0F38.W1 26 /rAVX512VL AVX512BW
VPTESTMW k2 {k1}, zmm2, zmm3/m512EVEX.512.66.0F38.W1 26 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vptestnmb<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVptestnmb<T, U, V>,

VPTESTNMB instruction

InstructionOpcodeCPUID
VPTESTNMB k2 {k1}, xmm2, xmm3/m128EVEX.128.F3.0F38.W0 26 /rAVX512VL AVX512BW
VPTESTNMB k2 {k1}, ymm2, ymm3/m256EVEX.256.F3.0F38.W0 26 /rAVX512VL AVX512BW
VPTESTNMB k2 {k1}, zmm2, zmm3/m512EVEX.512.F3.0F38.W0 26 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vptestnmd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVptestnmd<T, U, V>,

VPTESTNMD instruction

InstructionOpcodeCPUID
VPTESTNMD k2 {k1}, xmm2, xmm3/m128/m32bcstEVEX.128.F3.0F38.W0 27 /rAVX512VL AVX512F
VPTESTNMD k2 {k1}, ymm2, ymm3/m256/m32bcstEVEX.256.F3.0F38.W0 27 /rAVX512VL AVX512F
VPTESTNMD k2 {k1}, zmm2, zmm3/m512/m32bcstEVEX.512.F3.0F38.W0 27 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vptestnmq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVptestnmq<T, U, V>,

VPTESTNMQ instruction

InstructionOpcodeCPUID
VPTESTNMQ k2 {k1}, xmm2, xmm3/m128/m64bcstEVEX.128.F3.0F38.W1 27 /rAVX512VL AVX512F
VPTESTNMQ k2 {k1}, ymm2, ymm3/m256/m64bcstEVEX.256.F3.0F38.W1 27 /rAVX512VL AVX512F
VPTESTNMQ k2 {k1}, zmm2, zmm3/m512/m64bcstEVEX.512.F3.0F38.W1 27 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vptestnmw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVptestnmw<T, U, V>,

VPTESTNMW instruction

InstructionOpcodeCPUID
VPTESTNMW k2 {k1}, xmm2, xmm3/m128EVEX.128.F3.0F38.W1 26 /rAVX512VL AVX512BW
VPTESTNMW k2 {k1}, ymm2, ymm3/m256EVEX.256.F3.0F38.W1 26 /rAVX512VL AVX512BW
VPTESTNMW k2 {k1}, zmm2, zmm3/m512EVEX.512.F3.0F38.W1 26 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpunpckhbw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpunpckhbw<T, U, V>,

VPUNPCKHBW instruction

InstructionOpcodeCPUID
VPUNPCKHBW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 68 /rAVX
VPUNPCKHBW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 68 /rAVX2
VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 68 /rAVX512VL AVX512BW
VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 68 /rAVX512VL AVX512BW
VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 68 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpunpckhdq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpunpckhdq<T, U, V>,

VPUNPCKHDQ instruction

InstructionOpcodeCPUID
VPUNPCKHDQ xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 6A /rAVX
VPUNPCKHDQ ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 6A /rAVX2
VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 6A /rAVX512VL AVX512F
VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 6A /rAVX512VL AVX512F
VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 6A /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpunpckhqdq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpunpckhqdq<T, U, V>,

VPUNPCKHQDQ instruction

InstructionOpcodeCPUID
VPUNPCKHQDQ xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 6D /rAVX
VPUNPCKHQDQ ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 6D /rAVX2
VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 6D /rAVX512VL AVX512F
VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 6D /rAVX512VL AVX512F
VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 6D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpunpckhwd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpunpckhwd<T, U, V>,

VPUNPCKHWD instruction

InstructionOpcodeCPUID
VPUNPCKHWD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 69 /rAVX
VPUNPCKHWD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 69 /rAVX2
VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 69 /rAVX512VL AVX512BW
VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 69 /rAVX512VL AVX512BW
VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 69 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpunpcklbw<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpunpcklbw<T, U, V>,

VPUNPCKLBW instruction

InstructionOpcodeCPUID
VPUNPCKLBW xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 60 /rAVX
VPUNPCKLBW ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 60 /rAVX2
VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 60 /rAVX512VL AVX512BW
VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 60 /rAVX512VL AVX512BW
VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 60 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpunpckldq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpunpckldq<T, U, V>,

VPUNPCKLDQ instruction

InstructionOpcodeCPUID
VPUNPCKLDQ xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 62 /rAVX
VPUNPCKLDQ ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 62 /rAVX2
VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 62 /rAVX512VL AVX512F
VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 62 /rAVX512VL AVX512F
VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 62 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpunpcklqdq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpunpcklqdq<T, U, V>,

VPUNPCKLQDQ instruction

InstructionOpcodeCPUID
VPUNPCKLQDQ xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 6C /rAVX
VPUNPCKLQDQ ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 6C /rAVX2
VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 6C /rAVX512VL AVX512F
VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 6C /rAVX512VL AVX512F
VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 6C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpunpcklwd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpunpcklwd<T, U, V>,

VPUNPCKLWD instruction

InstructionOpcodeCPUID
VPUNPCKLWD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 61 /rAVX
VPUNPCKLWD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 61 /rAVX2
VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128EVEX.128.66.0F.WIG 61 /rAVX512VL AVX512BW
VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256EVEX.256.66.0F.WIG 61 /rAVX512VL AVX512BW
VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512EVEX.512.66.0F.WIG 61 /rAVX512BW
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpxor<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpxor<T, U, V>,

VPXOR instruction

InstructionOpcodeCPUID
VPXOR xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG EF /rAVX
VPXOR ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG EF /rAVX2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpxord<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpxord<T, U, V>,

VPXORD instruction

InstructionOpcodeCPUID
VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F.W0 EF /rAVX512VL AVX512F
VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F.W0 EF /rAVX512VL AVX512F
VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.66.0F.W0 EF /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vpxorq<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVpxorq<T, U, V>,

VPXORQ instruction

InstructionOpcodeCPUID
VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 EF /rAVX512VL AVX512F
VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 EF /rAVX512VL AVX512F
VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 EF /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 50 /r ibAVX512VL AVX512DQ
VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 50 /r ibAVX512VL AVX512DQ
VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8EVEX.512.66.0F3A.W1 50 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 50 /r ibAVX512VL AVX512DQ
VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 50 /r ibAVX512VL AVX512DQ
VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8EVEX.512.66.0F3A.W0 50 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.66.0F3A.W1 51 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.66.0F3A.W0 51 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vrcp14pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrcp14pd<T, U>,

VRCP14PD instruction

InstructionOpcodeCPUID
VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F38.W1 4C /rAVX512VL AVX512F
VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F38.W1 4C /rAVX512VL AVX512F
VRCP14PD zmm1 {k1}{z}, zmm2/m512/m64bcstEVEX.512.66.0F38.W1 4C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrcp14ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrcp14ps<T, U>,

VRCP14PS instruction

InstructionOpcodeCPUID
VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.0F38.W0 4C /rAVX512VL AVX512F
VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.0F38.W0 4C /rAVX512VL AVX512F
VRCP14PS zmm1 {k1}{z}, zmm2/m512/m32bcstEVEX.512.66.0F38.W0 4C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrcp14sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrcp14sd<T, U, V>,

VRCP14SD instruction

InstructionOpcodeCPUID
VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64EVEX.LIG.66.0F38.W1 4D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrcp14ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrcp14ss<T, U, V>,

VRCP14SS instruction

InstructionOpcodeCPUID
VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32EVEX.LIG.66.0F38.W0 4D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrcp28pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrcp28pd<T, U>,

VRCP28PD instruction

InstructionOpcodeCPUID
VRCP28PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}EVEX.512.66.0F38.W1 CA /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrcp28ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrcp28ps<T, U>,

VRCP28PS instruction

InstructionOpcodeCPUID
VRCP28PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}EVEX.512.66.0F38.W0 CA /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrcp28sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrcp28sd<T, U, V>,

VRCP28SD instruction

InstructionOpcodeCPUID
VRCP28SD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}EVEX.LIG.66.0F38.W1 CB /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrcp28ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrcp28ss<T, U, V>,

VRCP28SS instruction

InstructionOpcodeCPUID
VRCP28SS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}EVEX.LIG.66.0F38.W0 CB /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrcpph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrcpph<T, U>,

VRCPPH instruction

InstructionOpcodeCPUID
VRCPPH xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.66.MAP6.W0 4C /rAVX512VL AVX512-FP16
VRCPPH ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.66.MAP6.W0 4C /rAVX512VL AVX512-FP16
VRCPPH zmm1 {k1}{z}, zmm2/m512/m16bcstEVEX.512.66.MAP6.W0 4C /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrcpps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrcpps<T, U>,

VRCPPS instruction

InstructionOpcodeCPUID
VRCPPS xmm1, xmm2/m128VEX.128.0F.WIG 53 /rAVX
VRCPPS ymm1, ymm2/m256VEX.256.0F.WIG 53 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrcpsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrcpsh<T, U, V>,

VRCPSH instruction

InstructionOpcodeCPUID
VRCPSH xmm1 {k1}{z}, xmm2, xmm3/m16EVEX.LIG.66.MAP6.W0 4D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrcpss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrcpss<T, U, V>,

VRCPSS instruction

InstructionOpcodeCPUID
VRCPSS xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 53 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vreducepd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVreducepd<T, U, V>,

VREDUCEPD instruction

InstructionOpcodeCPUID
VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 56 /r ibAVX512VL AVX512DQ
VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 56 /r ibAVX512VL AVX512DQ
VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8EVEX.512.66.0F3A.W1 56 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vreduceph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVreduceph<T, U, V>,

VREDUCEPH instruction

InstructionOpcodeCPUID
VREDUCEPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8EVEX.128.0F3A.W0 56 /r ibAVX512VL AVX512-FP16
VREDUCEPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8EVEX.256.0F3A.W0 56 /r ibAVX512VL AVX512-FP16
VREDUCEPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 56 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vreduceps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVreduceps<T, U, V>,

VREDUCEPS instruction

InstructionOpcodeCPUID
VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 56 /r ibAVX512VL AVX512DQ
VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 56 /r ibAVX512VL AVX512DQ
VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8EVEX.512.66.0F3A.W0 56 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.66.0F3A.W1 57 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VREDUCESH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.0F3A.W0 57 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.66.0F3A.W0 57 /r ibAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vrndscalepd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrndscalepd<T, U, V>,

VRNDSCALEPD instruction

InstructionOpcodeCPUID
VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8EVEX.128.66.0F3A.W1 09 /r ibAVX512VL AVX512F
VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 09 /r ibAVX512VL AVX512F
VRNDSCALEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8EVEX.512.66.0F3A.W1 09 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrndscaleph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrndscaleph<T, U, V>,

VRNDSCALEPH instruction

InstructionOpcodeCPUID
VRNDSCALEPH xmm1 {k1}{z}, xmm2/m128/m16bcst, imm8EVEX.128.0F3A.W0 08 /r ibAVX512VL AVX512-FP16
VRNDSCALEPH ymm1 {k1}{z}, ymm2/m256/m16bcst, imm8EVEX.256.0F3A.W0 08 /r ibAVX512VL AVX512-FP16
VRNDSCALEPH zmm1 {k1}{z}, zmm2/m512/m16bcst{sae}, imm8EVEX.512.0F3A.W0 08 /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrndscaleps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrndscaleps<T, U, V>,

VRNDSCALEPS instruction

InstructionOpcodeCPUID
VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8EVEX.128.66.0F3A.W0 08 /r ibAVX512VL AVX512F
VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 08 /r ibAVX512VL AVX512F
VRNDSCALEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8EVEX.512.66.0F3A.W0 08 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8EVEX.LIG.66.0F3A.W1 0B /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VRNDSCALESH xmm1 {k1}{z}, xmm2, xmm3/m16{sae}, imm8EVEX.LIG.0F3A.W0 0A /r ibAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8EVEX.LIG.66.0F3A.W0 0A /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vroundpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVroundpd<T, U, V>,

VROUNDPD instruction

InstructionOpcodeCPUID
VROUNDPD xmm1, xmm2/m128, imm8VEX.128.66.0F3A.WIG 09 /r ibAVX
VROUNDPD ymm1, ymm2/m256, imm8VEX.256.66.0F3A.WIG 09 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vroundps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVroundps<T, U, V>,

VROUNDPS instruction

InstructionOpcodeCPUID
VROUNDPS xmm1, xmm2/m128, imm8VEX.128.66.0F3A.WIG 08 /r ibAVX
VROUNDPS ymm1, ymm2/m256, imm8VEX.256.66.0F3A.WIG 08 /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

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

InstructionOpcodeCPUID
VROUNDSD xmm1, xmm2, xmm3/m64, imm8VEX.LIG.66.0F3A.WIG 0B /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VROUNDSS xmm1, xmm2, xmm3/m32, imm8VEX.LIG.66.0F3A.WIG 0A /r ibAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vrsqrt14pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrsqrt14pd<T, U>,

VRSQRT14PD instruction

InstructionOpcodeCPUID
VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F38.W1 4E /rAVX512VL AVX512F
VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F38.W1 4E /rAVX512VL AVX512F
VRSQRT14PD zmm1 {k1}{z}, zmm2/m512/m64bcstEVEX.512.66.0F38.W1 4E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrsqrt14ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrsqrt14ps<T, U>,

VRSQRT14PS instruction

InstructionOpcodeCPUID
VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.66.0F38.W0 4E /rAVX512VL AVX512F
VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.66.0F38.W0 4E /rAVX512VL AVX512F
VRSQRT14PS zmm1 {k1}{z}, zmm2/m512/m32bcstEVEX.512.66.0F38.W0 4E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrsqrt14sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrsqrt14sd<T, U, V>,

VRSQRT14SD instruction

InstructionOpcodeCPUID
VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64EVEX.LIG.66.0F38.W1 4F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrsqrt14ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrsqrt14ss<T, U, V>,

VRSQRT14SS instruction

InstructionOpcodeCPUID
VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32EVEX.LIG.66.0F38.W0 4F /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrsqrt28pd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrsqrt28pd<T, U>,

VRSQRT28PD instruction

InstructionOpcodeCPUID
VRSQRT28PD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}EVEX.512.66.0F38.W1 CC /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrsqrt28ps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrsqrt28ps<T, U>,

VRSQRT28PS instruction

InstructionOpcodeCPUID
VRSQRT28PS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}EVEX.512.66.0F38.W0 CC /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrsqrt28sd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrsqrt28sd<T, U, V>,

VRSQRT28SD instruction

InstructionOpcodeCPUID
VRSQRT28SD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}EVEX.LIG.66.0F38.W1 CD /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrsqrt28ss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrsqrt28ss<T, U, V>,

VRSQRT28SS instruction

InstructionOpcodeCPUID
VRSQRT28SS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}EVEX.LIG.66.0F38.W0 CD /rAVX512ER
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrsqrtph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrsqrtph<T, U>,

VRSQRTPH instruction

InstructionOpcodeCPUID
VRSQRTPH xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.66.MAP6.W0 4E /rAVX512VL AVX512-FP16
VRSQRTPH ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.66.MAP6.W0 4E /rAVX512VL AVX512-FP16
VRSQRTPH zmm1 {k1}{z}, zmm2/m512/m16bcstEVEX.512.66.MAP6.W0 4E /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrsqrtps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVrsqrtps<T, U>,

VRSQRTPS instruction

InstructionOpcodeCPUID
VRSQRTPS xmm1, xmm2/m128VEX.128.0F.WIG 52 /rAVX
VRSQRTPS ymm1, ymm2/m256VEX.256.0F.WIG 52 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vrsqrtsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrsqrtsh<T, U, V>,

VRSQRTSH instruction

InstructionOpcodeCPUID
VRSQRTSH xmm1 {k1}{z}, xmm2, xmm3/m16EVEX.LIG.66.MAP6.W0 4F /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vrsqrtss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVrsqrtss<T, U, V>,

VRSQRTSS instruction

InstructionOpcodeCPUID
VRSQRTSS xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 52 /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vscalefpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVscalefpd<T, U, V>,

VSCALEFPD instruction

InstructionOpcodeCPUID
VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F38.W1 2C /rAVX512VL AVX512F
VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F38.W1 2C /rAVX512VL AVX512F
VSCALEFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F38.W1 2C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vscalefph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVscalefph<T, U, V>,

VSCALEFPH instruction

InstructionOpcodeCPUID
VSCALEFPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.66.MAP6.W0 2C /rAVX512VL AVX512-FP16
VSCALEFPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.66.MAP6.W0 2C /rAVX512VL AVX512-FP16
VSCALEFPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.66.MAP6.W0 2C /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vscalefps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVscalefps<T, U, V>,

VSCALEFPS instruction

InstructionOpcodeCPUID
VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.66.0F38.W0 2C /rAVX512VL AVX512F
VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.66.0F38.W0 2C /rAVX512VL AVX512F
VSCALEFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.66.0F38.W0 2C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vscalefsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVscalefsd<T, U, V>,

VSCALEFSD instruction

InstructionOpcodeCPUID
VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.66.0F38.W1 2D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vscalefsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVscalefsh<T, U, V>,

VSCALEFSH instruction

InstructionOpcodeCPUID
VSCALEFSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.66.MAP6.W0 2D /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vscalefss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVscalefss<T, U, V>,

VSCALEFSS instruction

InstructionOpcodeCPUID
VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.66.0F38.W0 2D /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vscatterdpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVscatterdpd<T, U>,

VSCATTERDPD instruction

InstructionOpcodeCPUID
VSCATTERDPD vm32x {k1}, xmm1EVEX.128.66.0F38.W1 A2 /vsibAVX512VL AVX512F
VSCATTERDPD vm32x {k1}, ymm1EVEX.256.66.0F38.W1 A2 /vsibAVX512VL AVX512F
VSCATTERDPD vm32y {k1}, zmm1EVEX.512.66.0F38.W1 A2 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vscatterdps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVscatterdps<T, U>,

VSCATTERDPS instruction

InstructionOpcodeCPUID
VSCATTERDPS vm32x {k1}, xmm1EVEX.128.66.0F38.W0 A2 /vsibAVX512VL AVX512F
VSCATTERDPS vm32y {k1}, ymm1EVEX.256.66.0F38.W0 A2 /vsibAVX512VL AVX512F
VSCATTERDPS vm32z {k1}, zmm1EVEX.512.66.0F38.W0 A2 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vscatterpf0dpd<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVscatterpf0dpd<T>,

VSCATTERPF0DPD instruction

InstructionOpcodeCPUID
VSCATTERPF0DPD vm32y {k1}EVEX.512.66.0F38.W1 C6 /5 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vscatterpf0dps<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVscatterpf0dps<T>,

VSCATTERPF0DPS instruction

InstructionOpcodeCPUID
VSCATTERPF0DPS vm32z {k1}EVEX.512.66.0F38.W0 C6 /5 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vscatterpf0qpd<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVscatterpf0qpd<T>,

VSCATTERPF0QPD instruction

InstructionOpcodeCPUID
VSCATTERPF0QPD vm64z {k1}EVEX.512.66.0F38.W1 C7 /5 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vscatterpf0qps<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVscatterpf0qps<T>,

VSCATTERPF0QPS instruction

InstructionOpcodeCPUID
VSCATTERPF0QPS vm64z {k1}EVEX.512.66.0F38.W0 C7 /5 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vscatterpf1dpd<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVscatterpf1dpd<T>,

VSCATTERPF1DPD instruction

InstructionOpcodeCPUID
VSCATTERPF1DPD vm32y {k1}EVEX.512.66.0F38.W1 C6 /6 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vscatterpf1dps<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVscatterpf1dps<T>,

VSCATTERPF1DPS instruction

InstructionOpcodeCPUID
VSCATTERPF1DPS vm32z {k1}EVEX.512.66.0F38.W0 C6 /6 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vscatterpf1qpd<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVscatterpf1qpd<T>,

VSCATTERPF1QPD instruction

InstructionOpcodeCPUID
VSCATTERPF1QPD vm64z {k1}EVEX.512.66.0F38.W1 C7 /6 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vscatterpf1qps<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVscatterpf1qps<T>,

VSCATTERPF1QPS instruction

InstructionOpcodeCPUID
VSCATTERPF1QPS vm64z {k1}EVEX.512.66.0F38.W0 C7 /6 /vsibAVX512PF
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vscatterqpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVscatterqpd<T, U>,

VSCATTERQPD instruction

InstructionOpcodeCPUID
VSCATTERQPD vm64x {k1}, xmm1EVEX.128.66.0F38.W1 A3 /vsibAVX512VL AVX512F
VSCATTERQPD vm64y {k1}, ymm1EVEX.256.66.0F38.W1 A3 /vsibAVX512VL AVX512F
VSCATTERQPD vm64z {k1}, zmm1EVEX.512.66.0F38.W1 A3 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vscatterqps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVscatterqps<T, U>,

VSCATTERQPS instruction

InstructionOpcodeCPUID
VSCATTERQPS vm64x {k1}, xmm1EVEX.128.66.0F38.W0 A3 /vsibAVX512VL AVX512F
VSCATTERQPS vm64y {k1}, xmm1EVEX.256.66.0F38.W0 A3 /vsibAVX512VL AVX512F
VSCATTERQPS vm64z {k1}, ymm1EVEX.512.66.0F38.W0 A3 /vsibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vsha512msg1<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVsha512msg1<T, U>,

VSHA512MSG1 instruction

InstructionOpcodeCPUID
VSHA512MSG1 ymm1, xmm2VEX.256.F2.0F38.W0 CC 11:rrr:bbbAVX 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
Source

pub fn vsha512msg2<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVsha512msg2<T, U>,

VSHA512MSG2 instruction

InstructionOpcodeCPUID
VSHA512MSG2 ymm1, ymm2VEX.256.F2.0F38.W0 CD 11:rrr:bbbAVX 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
Source

pub fn vsha512rnds2<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsha512rnds2<T, U, V>,

VSHA512RNDS2 instruction

InstructionOpcodeCPUID
VSHA512RNDS2 ymm1, ymm2, xmm3VEX.256.F2.0F38.W0 CB 11:rrr:bbbAVX 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
Source

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

InstructionOpcodeCPUID
VSHUFF32X4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 23 /r ibAVX512VL AVX512F
VSHUFF32X4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 23 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VSHUFF64X2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 23 /r ibAVX512VL AVX512F
VSHUFF64X2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 23 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VSHUFI32X4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.66.0F3A.W0 43 /r ibAVX512VL AVX512F
VSHUFI32X4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.66.0F3A.W0 43 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VSHUFI64X2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F3A.W1 43 /r ibAVX512VL AVX512F
VSHUFI64X2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F3A.W1 43 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VSHUFPD xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F.WIG C6 /r ibAVX
VSHUFPD ymm1, ymm2, ymm3/m256, imm8VEX.256.66.0F.WIG C6 /r ibAVX
VSHUFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8EVEX.128.66.0F.W1 C6 /r ibAVX512VL AVX512F
VSHUFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8EVEX.256.66.0F.W1 C6 /r ibAVX512VL AVX512F
VSHUFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8EVEX.512.66.0F.W1 C6 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

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

InstructionOpcodeCPUID
VSHUFPS xmm1, xmm2, xmm3/m128, imm8VEX.128.0F.WIG C6 /r ibAVX
VSHUFPS ymm1, ymm2, ymm3/m256, imm8VEX.256.0F.WIG C6 /r ibAVX
VSHUFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8EVEX.128.0F.W0 C6 /r ibAVX512VL AVX512F
VSHUFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8EVEX.256.0F.W0 C6 /r ibAVX512VL AVX512F
VSHUFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8EVEX.512.0F.W0 C6 /r ibAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/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
Source

pub fn vsm3msg1<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsm3msg1<T, U, V>,

VSM3MSG1 instruction

InstructionOpcodeCPUID
VSM3MSG1 xmm1, xmm2, xmm3/m128VEX.128.0F38.W0 DA /rAVX 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
Source

pub fn vsm3msg2<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsm3msg2<T, U, V>,

VSM3MSG2 instruction

InstructionOpcodeCPUID
VSM3MSG2 xmm1, xmm2, xmm3/m128VEX.128.66.0F38.W0 DA /rAVX 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
Source

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

InstructionOpcodeCPUID
VSM3RNDS2 xmm1, xmm2, xmm3/m128, imm8VEX.128.66.0F3A.W0 DE /r ibAVX 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
Source

pub fn vsm4key4<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsm4key4<T, U, V>,

VSM4KEY4 instruction

InstructionOpcodeCPUID
VSM4KEY4 xmm1, xmm2, xmm3/m128VEX.128.F3.0F38.W0 DA /rAVX SM4
VSM4KEY4 ymm1, ymm2, ymm3/m256VEX.256.F3.0F38.W0 DA /rAVX 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
Source

pub fn vsm4rnds4<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsm4rnds4<T, U, V>,

VSM4RNDS4 instruction

InstructionOpcodeCPUID
VSM4RNDS4 xmm1, xmm2, xmm3/m128VEX.128.F2.0F38.W0 DA /rAVX SM4
VSM4RNDS4 ymm1, ymm2, ymm3/m256VEX.256.F2.0F38.W0 DA /rAVX 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
Source

pub fn vsqrtpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVsqrtpd<T, U>,

VSQRTPD instruction

InstructionOpcodeCPUID
VSQRTPD xmm1, xmm2/m128VEX.128.66.0F.WIG 51 /rAVX
VSQRTPD ymm1, ymm2/m256VEX.256.66.0F.WIG 51 /rAVX
VSQRTPD xmm1 {k1}{z}, xmm2/m128/m64bcstEVEX.128.66.0F.W1 51 /rAVX512VL AVX512F
VSQRTPD ymm1 {k1}{z}, ymm2/m256/m64bcstEVEX.256.66.0F.W1 51 /rAVX512VL AVX512F
VSQRTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{er}EVEX.512.66.0F.W1 51 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vsqrtph<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVsqrtph<T, U>,

VSQRTPH instruction

InstructionOpcodeCPUID
VSQRTPH xmm1 {k1}{z}, xmm2/m128/m16bcstEVEX.128.MAP5.W0 51 /rAVX512VL AVX512-FP16
VSQRTPH ymm1 {k1}{z}, ymm2/m256/m16bcstEVEX.256.MAP5.W0 51 /rAVX512VL AVX512-FP16
VSQRTPH zmm1 {k1}{z}, zmm2/m512/m16bcst{er}EVEX.512.MAP5.W0 51 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vsqrtps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVsqrtps<T, U>,

VSQRTPS instruction

InstructionOpcodeCPUID
VSQRTPS xmm1, xmm2/m128VEX.128.0F.WIG 51 /rAVX
VSQRTPS ymm1, ymm2/m256VEX.256.0F.WIG 51 /rAVX
VSQRTPS xmm1 {k1}{z}, xmm2/m128/m32bcstEVEX.128.0F.W0 51 /rAVX512VL AVX512F
VSQRTPS ymm1 {k1}{z}, ymm2/m256/m32bcstEVEX.256.0F.W0 51 /rAVX512VL AVX512F
VSQRTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{er}EVEX.512.0F.W0 51 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vsqrtsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsqrtsd<T, U, V>,

VSQRTSD instruction

InstructionOpcodeCPUID
VSQRTSD xmm1, xmm2, xmm3/m64VEX.LIG.F2.0F.WIG 51 /rAVX
VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.F2.0F.W1 51 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vsqrtsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsqrtsh<T, U, V>,

VSQRTSH instruction

InstructionOpcodeCPUID
VSQRTSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.F3.MAP5.W0 51 /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vsqrtss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsqrtss<T, U, V>,

VSQRTSS instruction

InstructionOpcodeCPUID
VSQRTSS xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 51 /rAVX
VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.F3.0F.W0 51 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vstmxcsr<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmVstmxcsr<T>,

VSTMXCSR instruction

InstructionOpcodeCPUID
VSTMXCSR m32VEX.LZ.0F.WIG AE /3AVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn vsubpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsubpd<T, U, V>,

VSUBPD instruction

InstructionOpcodeCPUID
VSUBPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 5C /rAVX
VSUBPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 5C /rAVX
VSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 5C /rAVX512VL AVX512F
VSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 5C /rAVX512VL AVX512F
VSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}EVEX.512.66.0F.W1 5C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vsubph<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsubph<T, U, V>,

VSUBPH instruction

InstructionOpcodeCPUID
VSUBPH xmm1 {k1}{z}, xmm2, xmm3/m128/m16bcstEVEX.128.MAP5.W0 5C /rAVX512VL AVX512-FP16
VSUBPH ymm1 {k1}{z}, ymm2, ymm3/m256/m16bcstEVEX.256.MAP5.W0 5C /rAVX512VL AVX512-FP16
VSUBPH zmm1 {k1}{z}, zmm2, zmm3/m512/m16bcst{er}EVEX.512.MAP5.W0 5C /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vsubps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsubps<T, U, V>,

VSUBPS instruction

InstructionOpcodeCPUID
VSUBPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 5C /rAVX
VSUBPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 5C /rAVX
VSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 5C /rAVX512VL AVX512F
VSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 5C /rAVX512VL AVX512F
VSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}EVEX.512.0F.W0 5C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vsubsd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsubsd<T, U, V>,

VSUBSD instruction

InstructionOpcodeCPUID
VSUBSD xmm1, xmm2, xmm3/m64VEX.LIG.F2.0F.WIG 5C /rAVX
VSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er}EVEX.LIG.F2.0F.W1 5C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vsubsh<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsubsh<T, U, V>,

VSUBSH instruction

InstructionOpcodeCPUID
VSUBSH xmm1 {k1}{z}, xmm2, xmm3/m16{er}EVEX.LIG.F3.MAP5.W0 5C /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vsubss<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVsubss<T, U, V>,

VSUBSS instruction

InstructionOpcodeCPUID
VSUBSS xmm1, xmm2, xmm3/m32VEX.LIG.F3.0F.WIG 5C /rAVX
VSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er}EVEX.LIG.F3.0F.W0 5C /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vtestpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVtestpd<T, U>,

VTESTPD instruction

InstructionOpcodeCPUID
VTESTPD xmm1, xmm2/m128VEX.128.66.0F38.W0 0F /rAVX
VTESTPD ymm1, ymm2/m256VEX.256.66.0F38.W0 0F /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vtestps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVtestps<T, U>,

VTESTPS instruction

InstructionOpcodeCPUID
VTESTPS xmm1, xmm2/m128VEX.128.66.0F38.W0 0E /rAVX
VTESTPS ymm1, ymm2/m256VEX.256.66.0F38.W0 0E /rAVX
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vucomisd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVucomisd<T, U>,

VUCOMISD instruction

InstructionOpcodeCPUID
VUCOMISD xmm1, xmm2/m64VEX.LIG.66.0F.WIG 2E /rAVX
VUCOMISD xmm1, xmm2/m64{sae}EVEX.LIG.66.0F.W1 2E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vucomish<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVucomish<T, U>,

VUCOMISH instruction

InstructionOpcodeCPUID
VUCOMISH xmm1, xmm2/m16{sae}EVEX.LIG.MAP5.W0 2E /rAVX512-FP16
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vucomiss<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmVucomiss<T, U>,

VUCOMISS instruction

InstructionOpcodeCPUID
VUCOMISS xmm1, xmm2/m32VEX.LIG.0F.WIG 2E /rAVX
VUCOMISS xmm1, xmm2/m32{sae}EVEX.LIG.0F.W0 2E /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn vunpckhpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVunpckhpd<T, U, V>,

VUNPCKHPD instruction

InstructionOpcodeCPUID
VUNPCKHPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 15 /rAVX
VUNPCKHPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 15 /rAVX
VUNPCKHPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 15 /rAVX512VL AVX512F
VUNPCKHPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 15 /rAVX512VL AVX512F
VUNPCKHPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 15 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vunpckhps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVunpckhps<T, U, V>,

VUNPCKHPS instruction

InstructionOpcodeCPUID
VUNPCKHPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 15 /rAVX
VUNPCKHPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 15 /rAVX
VUNPCKHPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 15 /rAVX512VL AVX512F
VUNPCKHPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 15 /rAVX512VL AVX512F
VUNPCKHPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.0F.W0 15 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vunpcklpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVunpcklpd<T, U, V>,

VUNPCKLPD instruction

InstructionOpcodeCPUID
VUNPCKLPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 14 /rAVX
VUNPCKLPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 14 /rAVX
VUNPCKLPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 14 /rAVX512VL AVX512F
VUNPCKLPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 14 /rAVX512VL AVX512F
VUNPCKLPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 14 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vunpcklps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVunpcklps<T, U, V>,

VUNPCKLPS instruction

InstructionOpcodeCPUID
VUNPCKLPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 14 /rAVX
VUNPCKLPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 14 /rAVX
VUNPCKLPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 14 /rAVX512VL AVX512F
VUNPCKLPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 14 /rAVX512VL AVX512F
VUNPCKLPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.0F.W0 14 /rAVX512F
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vxorpd<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVxorpd<T, U, V>,

VXORPD instruction

InstructionOpcodeCPUID
VXORPD xmm1, xmm2, xmm3/m128VEX.128.66.0F.WIG 57 /rAVX
VXORPD ymm1, ymm2, ymm3/m256VEX.256.66.0F.WIG 57 /rAVX
VXORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstEVEX.128.66.0F.W1 57 /rAVX512VL AVX512DQ
VXORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstEVEX.256.66.0F.W1 57 /rAVX512VL AVX512DQ
VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstEVEX.512.66.0F.W1 57 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vxorps<T, U, V>( &mut self, op0: T, op1: U, op2: V, ) -> Result<(), IcedError>
where Self: CodeAsmVxorps<T, U, V>,

VXORPS instruction

InstructionOpcodeCPUID
VXORPS xmm1, xmm2, xmm3/m128VEX.128.0F.WIG 57 /rAVX
VXORPS ymm1, ymm2, ymm3/m256VEX.256.0F.WIG 57 /rAVX
VXORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstEVEX.128.0F.W0 57 /rAVX512VL AVX512DQ
VXORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstEVEX.256.0F.W0 57 /rAVX512VL AVX512DQ
VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstEVEX.512.0F.W0 57 /rAVX512DQ
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
  • op2: Third operand
Source

pub fn vzeroall(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVzeroall,

VZEROALL instruction

InstructionOpcodeCPUID
VZEROALLVEX.256.0F.WIG 77AVX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn vzeroupper(&mut self) -> Result<(), IcedError>
where Self: CodeAsmVzeroupper,

VZEROUPPER instruction

InstructionOpcodeCPUID
VZEROUPPERVEX.128.0F.WIG 77AVX
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn wait(&mut self) -> Result<(), IcedError>
where Self: CodeAsmWait,

WAIT instruction

InstructionOpcodeCPUID
WAIT9B8086+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn wbinvd(&mut self) -> Result<(), IcedError>
where Self: CodeAsmWbinvd,

WBINVD instruction

InstructionOpcodeCPUID
WBINVD0F 09486+
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn wbnoinvd(&mut self) -> Result<(), IcedError>
where Self: CodeAsmWbnoinvd,

WBNOINVD instruction

InstructionOpcodeCPUID
WBNOINVDF3 0F 09WBNOINVD
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn wrfsbase<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmWrfsbase<T>,

WRFSBASE instruction

InstructionOpcodeCPUID
WRFSBASE r32F3 0F AE /2FSGSBASE
WRFSBASE r64F3 o64 0F AE /2FSGSBASE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn wrgsbase<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmWrgsbase<T>,

WRGSBASE instruction

InstructionOpcodeCPUID
WRGSBASE r32F3 0F AE /3FSGSBASE
WRGSBASE r64F3 o64 0F AE /3FSGSBASE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn wrmsr(&mut self) -> Result<(), IcedError>
where Self: CodeAsmWrmsr,

WRMSR instruction

InstructionOpcodeCPUID
WRMSR0F 30MSR
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn wrmsrlist(&mut self) -> Result<(), IcedError>
where Self: CodeAsmWrmsrlist,

WRMSRLIST instruction

InstructionOpcodeCPUID
WRMSRLISTF3 0F 01 C6MSRLIST
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn wrmsrns(&mut self) -> Result<(), IcedError>
where Self: CodeAsmWrmsrns,

WRMSRNS instruction

InstructionOpcodeCPUID
WRMSRNSNP 0F 01 C6WRMSRNS
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn wrpkru(&mut self) -> Result<(), IcedError>
where Self: CodeAsmWrpkru,

WRPKRU instruction

InstructionOpcodeCPUID
WRPKRUNP 0F 01 EFPKU
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn wrshr<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmWrshr<T>,

WRSHR instruction

InstructionOpcodeCPUID
WRSHR r/m320F 37 /0Cyrix 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)
Source

pub fn wrssd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmWrssd<T, U>,

WRSSD instruction

InstructionOpcodeCPUID
WRSSD m32, r32NP 0F 38 F6 /rCET_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
Source

pub fn wrssq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmWrssq<T, U>,

WRSSQ instruction

InstructionOpcodeCPUID
WRSSQ m64, r64NP o64 0F 38 F6 /rCET_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
Source

pub fn wrudbg(&mut self) -> Result<(), IcedError>
where Self: CodeAsmWrudbg,

WRUDBG instruction

InstructionOpcodeCPUID
WRUDBG0F 0FUDBG
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn wrussd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmWrussd<T, U>,

WRUSSD instruction

InstructionOpcodeCPUID
WRUSSD m32, r3266 0F 38 F5 /rCET_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
Source

pub fn wrussq<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmWrussq<T, U>,

WRUSSQ instruction

InstructionOpcodeCPUID
WRUSSQ m64, r6466 o64 0F 38 F5 /rCET_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
Source

pub fn xabort<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXabort<T>,

XABORT instruction

InstructionOpcodeCPUID
XABORT imm8C6 F8 ibRTM
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xadd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmXadd<T, U>,

XADD instruction

InstructionOpcodeCPUID
XADD r/m8, r80F C0 /r486+
XADD r/m16, r16o16 0F C1 /r486+
XADD r/m32, r32o32 0F C1 /r486+
XADD r/m64, r64o64 0F C1 /rX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn xbegin<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXbegin<T>,

XBEGIN instruction

InstructionOpcodeCPUID
XBEGIN rel16o16 C7 F8 cwRTM
XBEGIN rel32o32 C7 F8 cdRTM
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xbts<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmXbts<T, U>,

XBTS instruction

InstructionOpcodeCPUID
XBTS r16, r/m16o16 0F A6 /r386 A0
XBTS r32, r/m32o32 0F A6 /r386 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
Source

pub fn xchg<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmXchg<T, U>,

XCHG instruction

InstructionOpcodeCPUID
XCHG r/m8, r886 /r8086+
XCHG r/m16, r16o16 87 /r8086+
XCHG r/m32, r32o32 87 /r386+
XCHG r/m64, r64o64 87 /rX64
XCHG r16, AXo16 90+rw8086+
XCHG r32, EAXo32 90+rd386+
XCHG r64, RAXo64 90+roX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn xcryptcbc(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXcryptcbc,

XCRYPTCBC instruction

InstructionOpcodeCPUID
XCRYPTCBCa16 F3 0F A7 D0PADLOCK_ACE
XCRYPTCBCa32 F3 0F A7 D0PADLOCK_ACE
XCRYPTCBCa64 F3 0F A7 D0PADLOCK_ACE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xcryptcfb(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXcryptcfb,

XCRYPTCFB instruction

InstructionOpcodeCPUID
XCRYPTCFBa16 F3 0F A7 E0PADLOCK_ACE
XCRYPTCFBa32 F3 0F A7 E0PADLOCK_ACE
XCRYPTCFBa64 F3 0F A7 E0PADLOCK_ACE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xcryptctr(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXcryptctr,

XCRYPTCTR instruction

InstructionOpcodeCPUID
XCRYPTCTRa16 F3 0F A7 D8PADLOCK_ACE
XCRYPTCTRa32 F3 0F A7 D8PADLOCK_ACE
XCRYPTCTRa64 F3 0F A7 D8PADLOCK_ACE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xcryptecb(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXcryptecb,

XCRYPTECB instruction

InstructionOpcodeCPUID
XCRYPTECBa16 F3 0F A7 C8PADLOCK_ACE
XCRYPTECBa32 F3 0F A7 C8PADLOCK_ACE
XCRYPTECBa64 F3 0F A7 C8PADLOCK_ACE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xcryptofb(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXcryptofb,

XCRYPTOFB instruction

InstructionOpcodeCPUID
XCRYPTOFBa16 F3 0F A7 E8PADLOCK_ACE
XCRYPTOFBa32 F3 0F A7 E8PADLOCK_ACE
XCRYPTOFBa64 F3 0F A7 E8PADLOCK_ACE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xend(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXend,

XEND instruction

InstructionOpcodeCPUID
XENDNP 0F 01 D5RTM
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xgetbv(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXgetbv,

XGETBV instruction

InstructionOpcodeCPUID
XGETBVNP 0F 01 D0XSAVE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xor<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmXor<T, U>,

XOR instruction

InstructionOpcodeCPUID
XOR r/m8, r830 /r8086+
XOR r/m16, r16o16 31 /r8086+
XOR r/m32, r32o32 31 /r386+
XOR r/m64, r64o64 31 /rX64
XOR r8, r/m832 /r8086+
XOR r16, r/m16o16 33 /r8086+
XOR r32, r/m32o32 33 /r386+
XOR r64, r/m64o64 33 /rX64
XOR AL, imm834 ib8086+
XOR AX, imm16o16 35 iw8086+
XOR EAX, imm32o32 35 id386+
XOR RAX, imm32o64 35 idX64
XOR r/m8, imm880 /6 ib8086+
XOR r/m16, imm16o16 81 /6 iw8086+
XOR r/m32, imm32o32 81 /6 id386+
XOR r/m64, imm32o64 81 /6 idX64
XOR r/m16, imm8o16 83 /6 ib8086+
XOR r/m32, imm8o32 83 /6 ib386+
XOR r/m64, imm8o64 83 /6 ibX64
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn xorpd<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmXorpd<T, U>,

XORPD instruction

InstructionOpcodeCPUID
XORPD xmm1, xmm2/m12866 0F 57 /rSSE2
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn xorps<T, U>(&mut self, op0: T, op1: U) -> Result<(), IcedError>
where Self: CodeAsmXorps<T, U>,

XORPS instruction

InstructionOpcodeCPUID
XORPS xmm1, xmm2/m128NP 0F 57 /rSSE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
  • op1: Second operand
Source

pub fn xresldtrk(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXresldtrk,

XRESLDTRK instruction

InstructionOpcodeCPUID
XRESLDTRKF2 0F 01 E9TSXLDTRK
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xrstor<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXrstor<T>,

XRSTOR instruction

InstructionOpcodeCPUID
XRSTOR memNP 0F AE /5XSAVE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xrstor64<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXrstor64<T>,

XRSTOR64 instruction

InstructionOpcodeCPUID
XRSTOR64 memNP o64 0F AE /5XSAVE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xrstors<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXrstors<T>,

XRSTORS instruction

InstructionOpcodeCPUID
XRSTORS memNP 0F C7 /3XSAVES
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xrstors64<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXrstors64<T>,

XRSTORS64 instruction

InstructionOpcodeCPUID
XRSTORS64 memNP o64 0F C7 /3XSAVES
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xsave<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXsave<T>,

XSAVE instruction

InstructionOpcodeCPUID
XSAVE memNP 0F AE /4XSAVE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xsave64<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXsave64<T>,

XSAVE64 instruction

InstructionOpcodeCPUID
XSAVE64 memNP o64 0F AE /4XSAVE
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xsavec<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXsavec<T>,

XSAVEC instruction

InstructionOpcodeCPUID
XSAVEC memNP 0F C7 /4XSAVEC
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xsavec64<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXsavec64<T>,

XSAVEC64 instruction

InstructionOpcodeCPUID
XSAVEC64 memNP o64 0F C7 /4XSAVEC
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xsaveopt<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXsaveopt<T>,

XSAVEOPT instruction

InstructionOpcodeCPUID
XSAVEOPT memNP 0F AE /6XSAVEOPT
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xsaveopt64<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXsaveopt64<T>,

XSAVEOPT64 instruction

InstructionOpcodeCPUID
XSAVEOPT64 memNP o64 0F AE /6XSAVEOPT
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xsaves<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXsaves<T>,

XSAVES instruction

InstructionOpcodeCPUID
XSAVES memNP 0F C7 /5XSAVES
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xsaves64<T>(&mut self, op0: T) -> Result<(), IcedError>
where Self: CodeAsmXsaves64<T>,

XSAVES64 instruction

InstructionOpcodeCPUID
XSAVES64 memNP o64 0F C7 /5XSAVES
§Errors

Fails if an operand is invalid (basic checks only)

§Arguments
  • op0: First operand (eg. an integer (a u32/i64/u64 number suffix is sometimes needed), a register (rdx), memory (dword_ptr(rcx+r13*4)) or a label)
Source

pub fn xsetbv(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXsetbv,

XSETBV instruction

InstructionOpcodeCPUID
XSETBVNP 0F 01 D1XSAVE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xsha1(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXsha1,

XSHA1 instruction

InstructionOpcodeCPUID
XSHA1a16 F3 0F A6 C8PADLOCK_PHE
XSHA1a32 F3 0F A6 C8PADLOCK_PHE
XSHA1a64 F3 0F A6 C8PADLOCK_PHE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xsha256(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXsha256,

XSHA256 instruction

InstructionOpcodeCPUID
XSHA256a16 F3 0F A6 D0PADLOCK_PHE
XSHA256a32 F3 0F A6 D0PADLOCK_PHE
XSHA256a64 F3 0F A6 D0PADLOCK_PHE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xsha512(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXsha512,

XSHA512 instruction

InstructionOpcodeCPUID
XSHA512a16 F3 0F A6 E0PADLOCK_PHE
XSHA512a32 F3 0F A6 E0PADLOCK_PHE
XSHA512a64 F3 0F A6 E0PADLOCK_PHE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xsha512_alt(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXsha512_alt,

XSHA512_ALT instruction

InstructionOpcodeCPUID
XSHA512_ALTa16 F3 0F A6 D8PADLOCK_PHE
XSHA512_ALTa32 F3 0F A6 D8PADLOCK_PHE
XSHA512_ALTa64 F3 0F A6 D8PADLOCK_PHE
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xstore(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXstore,

XSTORE instruction

InstructionOpcodeCPUID
XSTOREa16 0F A7 C0PADLOCK_RNG
XSTOREa32 0F A7 C0PADLOCK_RNG
XSTOREa64 0F A7 C0PADLOCK_RNG
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xstore_alt(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXstore_alt,

XSTORE_ALT instruction

InstructionOpcodeCPUID
XSTORE_ALTa16 F3 0F A7 F8PADLOCK_RNG
XSTORE_ALTa32 F3 0F A7 F8PADLOCK_RNG
XSTORE_ALTa64 F3 0F A7 F8PADLOCK_RNG
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xsusldtrk(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXsusldtrk,

XSUSLDTRK instruction

InstructionOpcodeCPUID
XSUSLDTRKF2 0F 01 E8TSXLDTRK
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn xtest(&mut self) -> Result<(), IcedError>
where Self: CodeAsmXtest,

XTEST instruction

InstructionOpcodeCPUID
XTESTNP 0F 01 D6HLE or RTM
§Errors

Fails if an operand is invalid (basic checks only)

Source

pub fn zero_bytes(&mut self) -> Result<(), IcedError>
where Self: CodeAsmZero_bytes,

ZERO_BYTES instruction

InstructionOpcodeCPUID
ZERO_BYTES<zero_bytes>8086+
§Errors

Fails if an operand is invalid (basic checks only)

Trait Implementations§

Source§

impl CodeAsmAaa for CodeAssembler

Source§

fn aaa(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmAad<i32> for CodeAssembler

Source§

fn aad(&mut self, op0: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAad<u32> for CodeAssembler

Source§

fn aad(&mut self, op0: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAadd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn aadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAadd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn aadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAam<i32> for CodeAssembler

Source§

fn aam(&mut self, op0: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAam<u32> for CodeAssembler

Source§

fn aam(&mut self, op0: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAand<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn aand( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAand<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn aand( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAas for CodeAssembler

Source§

fn aas(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister16, i32> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister16, u32> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister32, i32> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister32, u32> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister64, i32> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn adc( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister8, i32> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdc<AsmRegister8, u32> for CodeAssembler

Source§

fn adc(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAdcx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn adcx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdcx<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn adcx( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdcx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn adcx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdcx<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn adcx( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn add( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn add( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn add( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn add( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn add(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn add(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn add( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn add( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister16, i32> for CodeAssembler

Source§

fn add(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister16, u32> for CodeAssembler

Source§

fn add(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn add( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn add( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister32, i32> for CodeAssembler

Source§

fn add(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister32, u32> for CodeAssembler

Source§

fn add(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn add( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn add( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister64, i32> for CodeAssembler

Source§

fn add(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn add( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn add(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister8, i32> for CodeAssembler

Source§

fn add(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAdd<AsmRegister8, u32> for CodeAssembler

Source§

fn add(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAddpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn addpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmAddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAddps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn addps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmAddsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAddsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn addsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmAddss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAddss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn addss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmAddsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAddsubpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmAddsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAddsubps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmAdox<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn adox( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdox<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn adox( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdox<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn adox( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAdox<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn adox( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAesdec<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesdec<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmAesdec128kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesdec256kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesdeclast<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesdeclast<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmAesdecwide128kl<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesdecwide256kl<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesenc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesenc<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmAesenc128kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesenc256kl<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesenclast<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesenclast<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmAesencwide128kl<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesencwide256kl<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAesimc<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmAeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmAltinst for CodeAssembler

Source§

fn altinst(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn and( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn and( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn and( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn and( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn and(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn and(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn and( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn and( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister16, i32> for CodeAssembler

Source§

fn and(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister16, u32> for CodeAssembler

Source§

fn and(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn and( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn and( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister32, i32> for CodeAssembler

Source§

fn and(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister32, u32> for CodeAssembler

Source§

fn and(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn and( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn and( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister64, i32> for CodeAssembler

Source§

fn and(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn and( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn and(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister8, i32> for CodeAssembler

Source§

fn and(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmAnd<AsmRegister8, u32> for CodeAssembler

Source§

fn and(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmAndn<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAndn<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn andn( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAndn<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAndn<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn andn( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmAndnpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAndnpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmAndnps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAndnps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmAndpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAndpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn andpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmAndps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmAndps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn andps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmAor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn aor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn aor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn arpl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmArpl<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn arpl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmArpl<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn arpl( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmArpl<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn arpl( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAxor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn axor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmAxor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn axor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBb0_reset for CodeAssembler

Source§

impl CodeAsmBb1_reset for CodeAssembler

Source§

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBextr<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBextr<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBextr<AsmRegister32, AsmRegister32, i32> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBextr<AsmRegister32, AsmRegister32, u32> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBextr<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBextr<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBextr<AsmRegister64, AsmRegister64, i32> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBextr<AsmRegister64, AsmRegister64, u32> for CodeAssembler

Source§

fn bextr( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlcfill<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blcfill( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlcfill<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blcfill( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlci<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn blci( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlci<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blci( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlci<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn blci( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlci<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blci( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlcic<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blcic( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlcic<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blcic( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlcmsk<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blcmsk( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlcmsk<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blcmsk( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn blcs( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcs<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blcs( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn blcs( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlcs<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blcs( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlendpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn blendpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlendpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn blendpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlendpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn blendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlendpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn blendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlendps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn blendps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlendps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn blendps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlendps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn blendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlendps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn blendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlendvpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlendvpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmBlendvps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlendvps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmBlsfill<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlsfill<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blsfill( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsfill<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlsfill<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blsfill( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn blsi( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsi<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blsi( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn blsi( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsi<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blsi( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsic<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlsic<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blsic( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsic<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlsic<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blsic( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlsmsk<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blsmsk( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBlsmsk<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blsmsk( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn blsr( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsr<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn blsr( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn blsr( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBlsr<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn blsr( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBndcl<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBndcl<AsmRegisterBnd, AsmRegister32> for CodeAssembler

Source§

fn bndcl( &mut self, op0: AsmRegisterBnd, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBndcl<AsmRegisterBnd, AsmRegister64> for CodeAssembler

Source§

fn bndcl( &mut self, op0: AsmRegisterBnd, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBndcn<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBndcn<AsmRegisterBnd, AsmRegister32> for CodeAssembler

Source§

fn bndcn( &mut self, op0: AsmRegisterBnd, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBndcn<AsmRegisterBnd, AsmRegister64> for CodeAssembler

Source§

fn bndcn( &mut self, op0: AsmRegisterBnd, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBndcu<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBndcu<AsmRegisterBnd, AsmRegister32> for CodeAssembler

Source§

fn bndcu( &mut self, op0: AsmRegisterBnd, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBndcu<AsmRegisterBnd, AsmRegister64> for CodeAssembler

Source§

fn bndcu( &mut self, op0: AsmRegisterBnd, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBndldx<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBndmk<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBndmov<AsmMemoryOperand, AsmRegisterBnd> for CodeAssembler

Source§

impl CodeAsmBndmov<AsmRegisterBnd, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBndmov<AsmRegisterBnd, AsmRegisterBnd> for CodeAssembler

Source§

impl CodeAsmBndstx<AsmMemoryOperand, AsmRegisterBnd> for CodeAssembler

Source§

impl CodeAsmBound<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBound<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmBsf<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn bsf( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsf<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn bsf( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsf<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn bsf( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsf<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn bsf( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsf<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn bsf( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsf<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn bsf( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn bsr( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsr<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn bsr( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn bsr( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsr<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn bsr( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn bsr( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmBsr<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn bsr( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBswap<AsmRegister16> for CodeAssembler

Source§

fn bswap(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmBswap<AsmRegister32> for CodeAssembler

Source§

fn bswap(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmBswap<AsmRegister64> for CodeAssembler

Source§

fn bswap(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn bt( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn bt( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn bt( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn bt(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn bt(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn bt( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmRegister16, i32> for CodeAssembler

Source§

fn bt(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmRegister16, u32> for CodeAssembler

Source§

fn bt(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn bt( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmRegister32, i32> for CodeAssembler

Source§

fn bt(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmRegister32, u32> for CodeAssembler

Source§

fn bt(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn bt( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmRegister64, i32> for CodeAssembler

Source§

fn bt(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBt<AsmRegister64, u32> for CodeAssembler

Source§

fn bt(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn btc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn btc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn btc( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn btc(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn btc(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn btc( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmRegister16, i32> for CodeAssembler

Source§

fn btc(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmRegister16, u32> for CodeAssembler

Source§

fn btc(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn btc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmRegister32, i32> for CodeAssembler

Source§

fn btc(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmRegister32, u32> for CodeAssembler

Source§

fn btc(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn btc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmRegister64, i32> for CodeAssembler

Source§

fn btc(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBtc<AsmRegister64, u32> for CodeAssembler

Source§

fn btc(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn btr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn btr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn btr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn btr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn btr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn btr( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmRegister16, i32> for CodeAssembler

Source§

fn btr(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmRegister16, u32> for CodeAssembler

Source§

fn btr(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn btr( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmRegister32, i32> for CodeAssembler

Source§

fn btr(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmRegister32, u32> for CodeAssembler

Source§

fn btr(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn btr( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmRegister64, i32> for CodeAssembler

Source§

fn btr(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBtr<AsmRegister64, u32> for CodeAssembler

Source§

fn btr(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn bts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn bts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn bts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn bts(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn bts(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn bts( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmRegister16, i32> for CodeAssembler

Source§

fn bts(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmRegister16, u32> for CodeAssembler

Source§

fn bts(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn bts( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmRegister32, i32> for CodeAssembler

Source§

fn bts(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmRegister32, u32> for CodeAssembler

Source§

fn bts(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn bts( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmRegister64, i32> for CodeAssembler

Source§

fn bts(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmBts<AsmRegister64, u32> for CodeAssembler

Source§

fn bts(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmBzhi<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmBzhi<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn bzhi( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmBzhi<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmBzhi<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn bzhi( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCall<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCall<AsmRegister16> for CodeAssembler

Source§

fn call(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmCall<AsmRegister32> for CodeAssembler

Source§

fn call(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmCall<AsmRegister64> for CodeAssembler

Source§

fn call(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmCall<CodeLabel> for CodeAssembler

Source§

fn call(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmCall<u64> for CodeAssembler

Source§

fn call(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmCbw for CodeAssembler

Source§

fn cbw(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCcs_encrypt for CodeAssembler

Source§

impl CodeAsmCcs_hash for CodeAssembler

Source§

fn ccs_hash(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCdq for CodeAssembler

Source§

fn cdq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCdqe for CodeAssembler

Source§

fn cdqe(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCl1invmb for CodeAssembler

Source§

fn cl1invmb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmClac for CodeAssembler

Source§

fn clac(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmClc for CodeAssembler

Source§

fn clc(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCld for CodeAssembler

Source§

fn cld(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCldemote<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmClflush<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmClflushopt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmClgi for CodeAssembler

Source§

fn clgi(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCli for CodeAssembler

Source§

fn cli(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmClrssbsy<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmClts for CodeAssembler

Source§

fn clts(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmClui for CodeAssembler

Source§

fn clui(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmClwb<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmClzero for CodeAssembler

Source§

fn clzero(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCmc for CodeAssembler

Source§

fn cmc(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCmova<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmova<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmova( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmova<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmova<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmova( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmova<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmova<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmova( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovae<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovae( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovae<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovae( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovae<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovae( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovb<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovb( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovb<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovb( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovb<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovb( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovbe<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovbe( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovbe<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovbe( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovbe<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovbe( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovc<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovc( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovc<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovc<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmove<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmove<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmove( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmove<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmove<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmove( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmove<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmove<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmove( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovg<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovg<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovg( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovg<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovg<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovg( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovg<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovg<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovg( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovge<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovge( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovge<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovge( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovge<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovge( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovl<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovl( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovl<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovl( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovl<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovl( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovle<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovle( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovle<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovle( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovle<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovle( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovna<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovna<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovna( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovna<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovna<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovna( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovna<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovna<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovna( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnae<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnae<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovnae( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnae<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnae<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovnae( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnae<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnae<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovnae( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnb<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovnb( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnb<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovnb( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnb<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovnb( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnbe<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovnbe( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnbe<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovnbe( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnbe<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovnbe( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnc<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnc<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovnc( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnc<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovnc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnc<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovnc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovne<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovne<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovne( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovne<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovne<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovne( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovne<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovne<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovne( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovng<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovng<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovng( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovng<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovng<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovng( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovng<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovng<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovng( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnge<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnge<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovnge( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnge<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnge<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovnge( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnge<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnge<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovnge( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnl<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovnl( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnl<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovnl( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnl<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnl<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovnl( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnle<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnle<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovnle( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnle<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnle<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovnle( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnle<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnle<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovnle( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovno<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovno<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovno( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovno<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovno<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovno( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovno<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovno<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovno( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnp<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovnp( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnp<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovnp( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnp<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovnp( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovns<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovns<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovns( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovns<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovns<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovns( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovns<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovns<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovns( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnz<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovnz( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnz<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovnz( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovnz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovnz<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovnz( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovo<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovo( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovo<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovo( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovo<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovo( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovp<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovp( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovp<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovp( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovp<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovp( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovpe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovpe<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovpe( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovpe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovpe<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovpe( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovpe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovpe<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovpe( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovpo<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovpo<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovpo( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovpo<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovpo<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovpo( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovpo<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovpo<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovpo( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovs<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovs( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovs<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovs( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovs<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovs( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovz<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovz<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmovz( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovz<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovz<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmovz( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmovz<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmovz<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmovz( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister16, i32> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister16, u32> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister32, i32> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister32, u32> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister64, i32> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn cmp( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister8, i32> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmCmp<AsmRegister8, u32> for CodeAssembler

Source§

fn cmp(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmCmpbexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpbexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpbxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpbxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpcxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpcxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpeqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpeqpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpeqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpeqps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpeqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpeqsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpeqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpeqss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmplepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmplepd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpleps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmplesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmplesd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpless<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmplexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmplexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpltpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpltps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpltsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpltss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmplxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmplxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnaexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnaexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnaxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnaxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnbexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnbexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnbxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnbxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpncxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpncxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpneqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpneqpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpneqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpneqps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpneqsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpneqsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpneqss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpneqss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpngexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpngexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpngxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpngxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnlepd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpnlepd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpnleps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpnleps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpnlesd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpnlesd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpnless<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpnless<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpnlexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnlexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnltpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpnltpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpnltps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpnltps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpnltsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpnltsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpnltss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpnltss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpnlxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnlxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnoxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnpxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnpxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnsxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnsxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpnzxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpnzxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpordpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpordps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpordsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpordss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpoxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn cmppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmppd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn cmppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmppd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn cmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmppd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn cmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmppexadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmppexadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmppoxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmppoxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn cmpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn cmpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn cmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn cmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmppxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmppxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpsb for CodeAssembler

Source§

fn cmpsb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCmpsd for CodeAssembler

Source§

fn cmpsd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn cmpsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn cmpsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn cmpsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpsd3<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn cmpsd_3( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpsq for CodeAssembler

Source§

fn cmpsq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCmpss<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn cmpss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpss<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn cmpss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpss<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn cmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpss<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn cmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpsw for CodeAssembler

Source§

fn cmpsw(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCmpsxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpsxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpunordpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpunordpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpunordps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpunordps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpunordsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpunordsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpunordss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpunordss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCmpxchg<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

impl CodeAsmCmpxchg<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn cmpxchg( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpxchg<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn cmpxchg( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpxchg<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn cmpxchg( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpxchg<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn cmpxchg( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmCmpxchg16b<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpxchg8b<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCmpzxadd<AsmMemoryOperand, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCmpzxadd<AsmMemoryOperand, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmComisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmComisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmComiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmComiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCpu_read for CodeAssembler

Source§

fn cpu_read(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCpu_write for CodeAssembler

Source§

impl CodeAsmCpuid for CodeAssembler

Source§

fn cpuid(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCqo for CodeAssembler

Source§

fn cqo(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCrc32<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCrc32<AsmRegister32, AsmRegister16> for CodeAssembler

Source§

fn crc32( &mut self, op0: AsmRegister32, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmCrc32<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn crc32( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmCrc32<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn crc32( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmCrc32<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCrc32<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn crc32( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmCrc32<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn crc32( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmCvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtdq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtdq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtdq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtpd2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtpd2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtpd2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtpi2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtpi2pd<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmCvtpi2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtpi2ps<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmCvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtps2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtps2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtsd2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtsd2ss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCvtsi2sd<AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmCvtsi2ss<AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmCvtss2sd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtss2sd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvtss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvttpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvttpd2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvttpd2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvttps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvttps2pi<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvttps2pi<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvttsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvttsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvttss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmCvttss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmCwd for CodeAssembler

Source§

fn cwd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmCwde for CodeAssembler

Source§

fn cwde(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmDaa for CodeAssembler

Source§

fn daa(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmDas for CodeAssembler

Source§

fn das(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmDec<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmDec<AsmRegister16> for CodeAssembler

Source§

fn dec(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmDec<AsmRegister32> for CodeAssembler

Source§

fn dec(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmDec<AsmRegister64> for CodeAssembler

Source§

fn dec(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmDec<AsmRegister8> for CodeAssembler

Source§

fn dec(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmDiv<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmDiv<AsmRegister16> for CodeAssembler

Source§

fn div(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmDiv<AsmRegister32> for CodeAssembler

Source§

fn div(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmDiv<AsmRegister64> for CodeAssembler

Source§

fn div(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmDiv<AsmRegister8> for CodeAssembler

Source§

fn div(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmDivpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmDivpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn divpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmDivps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmDivps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn divps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmDivsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmDivsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn divsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmDivss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmDivss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn divss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmDmint for CodeAssembler

Source§

fn dmint(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmDppd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn dppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmDppd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn dppd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmDppd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn dppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmDppd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn dppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmDpps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn dpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmDpps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn dpps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmDpps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn dpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmDpps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn dpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmEmms for CodeAssembler

Source§

fn emms(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmEncls for CodeAssembler

Source§

fn encls(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmEnclu for CodeAssembler

Source§

fn enclu(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmEnclv for CodeAssembler

Source§

fn enclv(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmEncodekey128<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmEncodekey256<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmEndbr32 for CodeAssembler

Source§

fn endbr32(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmEndbr64 for CodeAssembler

Source§

fn endbr64(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmEnqcmd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmEnqcmd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmEnqcmd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmEnqcmds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmEnqcmds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmEnqcmds<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmEnter<i32, i32> for CodeAssembler

Source§

fn enter(&mut self, op0: i32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmEnter<u32, u32> for CodeAssembler

Source§

fn enter(&mut self, op0: u32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmErets for CodeAssembler

Source§

fn erets(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmEretu for CodeAssembler

Source§

fn eretu(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmExtractps<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn extractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmExtractps<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn extractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmExtractps<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn extractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmExtractps<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn extractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmExtractps<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn extractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmExtractps<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn extractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmExtrq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn extrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmExtrq3<AsmRegisterXmm, i32, i32> for CodeAssembler

Source§

fn extrq_3( &mut self, op0: AsmRegisterXmm, op1: i32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmExtrq3<AsmRegisterXmm, u32, u32> for CodeAssembler

Source§

fn extrq_3( &mut self, op0: AsmRegisterXmm, op1: u32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmF2xm1 for CodeAssembler

Source§

fn f2xm1(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFabs for CodeAssembler

Source§

fn fabs(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFadd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFadd2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fadd_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFaddp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn faddp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFbld<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFbstp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFchs for CodeAssembler

Source§

fn fchs(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFclex for CodeAssembler

Source§

fn fclex(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFcmovb<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcmovb( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcmovbe<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcmovbe( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcmove<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcmove( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcmovnb<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcmovnb( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcmovnbe<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

impl CodeAsmFcmovne<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcmovne( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcmovnu<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcmovnu( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcmovu<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcmovu( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcom<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFcom2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcom_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcomi<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcomi( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcomip<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcomip( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcomp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFcomp2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fcomp_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFcompp for CodeAssembler

Source§

fn fcompp(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFcos for CodeAssembler

Source§

fn fcos(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFdecstp for CodeAssembler

Source§

fn fdecstp(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFdisi for CodeAssembler

Source§

fn fdisi(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFdiv<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFdiv2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fdiv_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFdivp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fdivp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFdivr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFdivr2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fdivr_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFdivrp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fdivrp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFemms for CodeAssembler

Source§

fn femms(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFeni for CodeAssembler

Source§

fn feni(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFfree<AsmRegisterSt> for CodeAssembler

Source§

fn ffree(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

Source§

impl CodeAsmFfreep<AsmRegisterSt> for CodeAssembler

Source§

impl CodeAsmFiadd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFicom<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFicomp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFidiv<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFidivr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFild<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFimul<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFincstp for CodeAssembler

Source§

fn fincstp(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFinit for CodeAssembler

Source§

fn finit(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFist<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFistp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFisttp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFisub<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFisubr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFld<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFld<AsmRegisterSt> for CodeAssembler

Source§

fn fld(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

Source§

impl CodeAsmFld1 for CodeAssembler

Source§

fn fld1(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFldcw<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFldenv<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFldl2e for CodeAssembler

Source§

fn fldl2e(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFldl2t for CodeAssembler

Source§

fn fldl2t(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFldlg2 for CodeAssembler

Source§

fn fldlg2(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFldln2 for CodeAssembler

Source§

fn fldln2(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFldpi for CodeAssembler

Source§

fn fldpi(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFldz for CodeAssembler

Source§

fn fldz(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFmul<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFmul2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fmul_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFmulp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fmulp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFnclex for CodeAssembler

Source§

fn fnclex(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFndisi for CodeAssembler

Source§

fn fndisi(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFneni for CodeAssembler

Source§

fn fneni(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFninit for CodeAssembler

Source§

fn fninit(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFnop for CodeAssembler

Source§

fn fnop(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFnsave<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFnsetpm for CodeAssembler

Source§

fn fnsetpm(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFnstcw<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFnstdw<AsmRegister16> for CodeAssembler

Source§

impl CodeAsmFnstenv<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFnstsg<AsmRegister16> for CodeAssembler

Source§

impl CodeAsmFnstsw<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFnstsw<AsmRegister16> for CodeAssembler

Source§

impl CodeAsmFpatan for CodeAssembler

Source§

fn fpatan(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFprem for CodeAssembler

Source§

fn fprem(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFprem1 for CodeAssembler

Source§

fn fprem1(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFptan for CodeAssembler

Source§

fn fptan(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFrndint for CodeAssembler

Source§

fn frndint(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFrstor<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFrstpm for CodeAssembler

Source§

fn frstpm(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFsave<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFscale for CodeAssembler

Source§

fn fscale(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFsetpm for CodeAssembler

Source§

fn fsetpm(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFsin for CodeAssembler

Source§

fn fsin(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFsincos for CodeAssembler

Source§

fn fsincos(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFsqrt for CodeAssembler

Source§

fn fsqrt(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFst<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFst<AsmRegisterSt> for CodeAssembler

Source§

fn fst(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

Source§

impl CodeAsmFstcw<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFstdw<AsmRegister16> for CodeAssembler

Source§

fn fstdw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmFstenv<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFstp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFstp<AsmRegisterSt> for CodeAssembler

Source§

fn fstp(&mut self, op0: AsmRegisterSt) -> Result<(), IcedError>

Source§

impl CodeAsmFstpnce<AsmRegisterSt> for CodeAssembler

Source§

impl CodeAsmFstsg<AsmRegister16> for CodeAssembler

Source§

fn fstsg(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmFstsw<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFstsw<AsmRegister16> for CodeAssembler

Source§

fn fstsw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmFsub<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFsub2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fsub_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFsubp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fsubp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFsubr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFsubr2<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fsubr_2( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFsubrp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fsubrp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFtst for CodeAssembler

Source§

fn ftst(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFucom<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fucom( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFucomi<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fucomi( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFucomip<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fucomip( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFucomp<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fucomp( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFucompp for CodeAssembler

Source§

fn fucompp(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFxam for CodeAssembler

Source§

fn fxam(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFxch<AsmRegisterSt, AsmRegisterSt> for CodeAssembler

Source§

fn fxch( &mut self, op0: AsmRegisterSt, op1: AsmRegisterSt, ) -> Result<(), IcedError>

Source§

impl CodeAsmFxrstor<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFxrstor64<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFxsave<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFxsave64<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmFxtract for CodeAssembler

Source§

fn fxtract(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFyl2x for CodeAssembler

Source§

fn fyl2x(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmFyl2xp1 for CodeAssembler

Source§

fn fyl2xp1(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmGetsec for CodeAssembler

Source§

fn getsec(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmGetsecq for CodeAssembler

Source§

fn getsecq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmGf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn gf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmGf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn gf2p8affineqb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmGf2p8mulb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmGf2p8mulb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmHaddpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmHaddpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmHaddps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmHaddps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmHlt for CodeAssembler

Source§

fn hlt(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmHreset<i32> for CodeAssembler

Source§

fn hreset(&mut self, op0: i32) -> Result<(), IcedError>

Source§

impl CodeAsmHreset<u32> for CodeAssembler

Source§

fn hreset(&mut self, op0: u32) -> Result<(), IcedError>

Source§

impl CodeAsmHsubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmHsubpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmHsubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmHsubps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn ibts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmIbts<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn ibts( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmIbts<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn ibts( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmIbts<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn ibts( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmIdiv<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmIdiv<AsmRegister16> for CodeAssembler

Source§

fn idiv(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmIdiv<AsmRegister32> for CodeAssembler

Source§

fn idiv(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmIdiv<AsmRegister64> for CodeAssembler

Source§

fn idiv(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmIdiv<AsmRegister8> for CodeAssembler

Source§

fn idiv(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmImul<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmImul<AsmRegister16> for CodeAssembler

Source§

fn imul(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmImul<AsmRegister32> for CodeAssembler

Source§

fn imul(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmImul<AsmRegister64> for CodeAssembler

Source§

fn imul(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmImul<AsmRegister8> for CodeAssembler

Source§

fn imul(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmImul2<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmImul2<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn imul_2( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul2<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmImul2<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn imul_2( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul2<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmImul2<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn imul_2( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister16, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister16, AsmRegister16, i32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister16, AsmRegister16, u32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister32, AsmRegister32, i32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister32, AsmRegister32, u32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmImul3<AsmRegister64, AsmRegister64, i32> for CodeAssembler

Source§

fn imul_3( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmIn<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn in_( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmIn<AsmRegister16, i32> for CodeAssembler

Source§

fn in_(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmIn<AsmRegister16, u32> for CodeAssembler

Source§

fn in_(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmIn<AsmRegister32, AsmRegister16> for CodeAssembler

Source§

fn in_( &mut self, op0: AsmRegister32, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmIn<AsmRegister32, i32> for CodeAssembler

Source§

fn in_(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmIn<AsmRegister32, u32> for CodeAssembler

Source§

fn in_(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmIn<AsmRegister8, AsmRegister16> for CodeAssembler

Source§

fn in_( &mut self, op0: AsmRegister8, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmIn<AsmRegister8, i32> for CodeAssembler

Source§

fn in_(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmIn<AsmRegister8, u32> for CodeAssembler

Source§

fn in_(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmInc<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmInc<AsmRegister16> for CodeAssembler

Source§

fn inc(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmInc<AsmRegister32> for CodeAssembler

Source§

fn inc(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmInc<AsmRegister64> for CodeAssembler

Source§

fn inc(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmInc<AsmRegister8> for CodeAssembler

Source§

fn inc(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmIncsspd<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmIncsspq<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmInsb for CodeAssembler

Source§

fn insb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmInsd for CodeAssembler

Source§

fn insd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmInsertps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn insertps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmInsertps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn insertps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmInsertps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn insertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmInsertps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn insertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmInsertq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmInsertq4<AsmRegisterXmm, AsmRegisterXmm, i32, i32> for CodeAssembler

Source§

fn insertq_4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmInsertq4<AsmRegisterXmm, AsmRegisterXmm, u32, u32> for CodeAssembler

Source§

fn insertq_4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmInsw for CodeAssembler

Source§

fn insw(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmInt<i32> for CodeAssembler

Source§

fn int(&mut self, op0: i32) -> Result<(), IcedError>

Source§

impl CodeAsmInt<u32> for CodeAssembler

Source§

fn int(&mut self, op0: u32) -> Result<(), IcedError>

Source§

impl CodeAsmInt1 for CodeAssembler

Source§

fn int1(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmInt3 for CodeAssembler

Source§

fn int3(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmInto for CodeAssembler

Source§

fn into(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmInvd for CodeAssembler

Source§

fn invd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmInvept<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmInvept<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmInvlpg<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmInvlpga for CodeAssembler

Source§

fn invlpga(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmInvlpgb for CodeAssembler

Source§

fn invlpgb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmInvpcid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmInvpcid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmInvvpid<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmInvvpid<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmIret for CodeAssembler

Source§

fn iret(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmIretd for CodeAssembler

Source§

fn iretd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmIretq for CodeAssembler

Source§

fn iretq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmJa<CodeLabel> for CodeAssembler

Source§

fn ja(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJa<u64> for CodeAssembler

Source§

fn ja(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJae<CodeLabel> for CodeAssembler

Source§

fn jae(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJae<u64> for CodeAssembler

Source§

fn jae(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJb<CodeLabel> for CodeAssembler

Source§

fn jb(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJb<u64> for CodeAssembler

Source§

fn jb(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJbe<CodeLabel> for CodeAssembler

Source§

fn jbe(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJbe<u64> for CodeAssembler

Source§

fn jbe(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJc<CodeLabel> for CodeAssembler

Source§

fn jc(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJc<u64> for CodeAssembler

Source§

fn jc(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJcxz<CodeLabel> for CodeAssembler

Source§

fn jcxz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJcxz<u64> for CodeAssembler

Source§

fn jcxz(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJe<CodeLabel> for CodeAssembler

Source§

fn je(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJe<u64> for CodeAssembler

Source§

fn je(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJecxz<CodeLabel> for CodeAssembler

Source§

fn jecxz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJecxz<u64> for CodeAssembler

Source§

fn jecxz(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJg<CodeLabel> for CodeAssembler

Source§

fn jg(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJg<u64> for CodeAssembler

Source§

fn jg(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJge<CodeLabel> for CodeAssembler

Source§

fn jge(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJge<u64> for CodeAssembler

Source§

fn jge(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJl<CodeLabel> for CodeAssembler

Source§

fn jl(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJl<u64> for CodeAssembler

Source§

fn jl(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJle<CodeLabel> for CodeAssembler

Source§

fn jle(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJle<u64> for CodeAssembler

Source§

fn jle(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJmp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmJmp<AsmRegister16> for CodeAssembler

Source§

fn jmp(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmJmp<AsmRegister32> for CodeAssembler

Source§

fn jmp(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmJmp<AsmRegister64> for CodeAssembler

Source§

fn jmp(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmJmp<CodeLabel> for CodeAssembler

Source§

fn jmp(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJmp<u64> for CodeAssembler

Source§

fn jmp(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJmpe<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmJmpe<AsmRegister16> for CodeAssembler

Source§

fn jmpe(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmJmpe<AsmRegister32> for CodeAssembler

Source§

fn jmpe(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmJmpe<CodeLabel> for CodeAssembler

Source§

fn jmpe(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJmpe<u64> for CodeAssembler

Source§

fn jmpe(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJna<CodeLabel> for CodeAssembler

Source§

fn jna(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJna<u64> for CodeAssembler

Source§

fn jna(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJnae<CodeLabel> for CodeAssembler

Source§

fn jnae(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJnae<u64> for CodeAssembler

Source§

fn jnae(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJnb<CodeLabel> for CodeAssembler

Source§

fn jnb(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJnb<u64> for CodeAssembler

Source§

fn jnb(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJnbe<CodeLabel> for CodeAssembler

Source§

fn jnbe(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJnbe<u64> for CodeAssembler

Source§

fn jnbe(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJnc<CodeLabel> for CodeAssembler

Source§

fn jnc(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJnc<u64> for CodeAssembler

Source§

fn jnc(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJne<CodeLabel> for CodeAssembler

Source§

fn jne(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJne<u64> for CodeAssembler

Source§

fn jne(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJng<CodeLabel> for CodeAssembler

Source§

fn jng(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJng<u64> for CodeAssembler

Source§

fn jng(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJnge<CodeLabel> for CodeAssembler

Source§

fn jnge(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJnge<u64> for CodeAssembler

Source§

fn jnge(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJnl<CodeLabel> for CodeAssembler

Source§

fn jnl(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJnl<u64> for CodeAssembler

Source§

fn jnl(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJnle<CodeLabel> for CodeAssembler

Source§

fn jnle(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJnle<u64> for CodeAssembler

Source§

fn jnle(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJno<CodeLabel> for CodeAssembler

Source§

fn jno(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJno<u64> for CodeAssembler

Source§

fn jno(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJnp<CodeLabel> for CodeAssembler

Source§

fn jnp(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJnp<u64> for CodeAssembler

Source§

fn jnp(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJns<CodeLabel> for CodeAssembler

Source§

fn jns(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJns<u64> for CodeAssembler

Source§

fn jns(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJnz<CodeLabel> for CodeAssembler

Source§

fn jnz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJnz<u64> for CodeAssembler

Source§

fn jnz(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJo<CodeLabel> for CodeAssembler

Source§

fn jo(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJo<u64> for CodeAssembler

Source§

fn jo(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJp<CodeLabel> for CodeAssembler

Source§

fn jp(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJp<u64> for CodeAssembler

Source§

fn jp(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJpe<CodeLabel> for CodeAssembler

Source§

fn jpe(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJpe<u64> for CodeAssembler

Source§

fn jpe(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJpo<CodeLabel> for CodeAssembler

Source§

fn jpo(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJpo<u64> for CodeAssembler

Source§

fn jpo(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJrcxz<CodeLabel> for CodeAssembler

Source§

fn jrcxz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJrcxz<u64> for CodeAssembler

Source§

fn jrcxz(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJs<CodeLabel> for CodeAssembler

Source§

fn js(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJs<u64> for CodeAssembler

Source§

fn js(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmJz<CodeLabel> for CodeAssembler

Source§

fn jz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmJz<u64> for CodeAssembler

Source§

fn jz(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmKaddb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kaddb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKaddd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kaddd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKaddq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kaddq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKaddw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kaddw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKandb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kandb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKandd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kandd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKandnb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kandnb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKandnd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kandnd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKandnq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kandnq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKandnw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kandnw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKandq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kandq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKandw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kandw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovb<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

Source§

fn kmovb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovb<AsmRegister32, AsmRegisterK> for CodeAssembler

Source§

fn kmovb( &mut self, op0: AsmRegister32, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovb<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

Source§

fn kmovb( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovb<AsmRegisterK, AsmRegister32> for CodeAssembler

Source§

fn kmovb( &mut self, op0: AsmRegisterK, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovb<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kmovb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovd<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

Source§

fn kmovd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovd<AsmRegister32, AsmRegisterK> for CodeAssembler

Source§

fn kmovd( &mut self, op0: AsmRegister32, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovd<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

Source§

fn kmovd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovd<AsmRegisterK, AsmRegister32> for CodeAssembler

Source§

fn kmovd( &mut self, op0: AsmRegisterK, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovd<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kmovd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovq<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

Source§

fn kmovq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovq<AsmRegister64, AsmRegisterK> for CodeAssembler

Source§

fn kmovq( &mut self, op0: AsmRegister64, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovq<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

Source§

fn kmovq( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovq<AsmRegisterK, AsmRegister64> for CodeAssembler

Source§

fn kmovq( &mut self, op0: AsmRegisterK, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovq<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kmovq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovw<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

Source§

fn kmovw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovw<AsmRegister32, AsmRegisterK> for CodeAssembler

Source§

fn kmovw( &mut self, op0: AsmRegister32, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovw<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

Source§

fn kmovw( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovw<AsmRegisterK, AsmRegister32> for CodeAssembler

Source§

fn kmovw( &mut self, op0: AsmRegisterK, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKmovw<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kmovw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKnotb<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn knotb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKnotd<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn knotd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKnotq<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn knotq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKnotw<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn knotw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKorb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn korb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKord<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kord( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKorq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn korq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKortestb<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kortestb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKortestd<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kortestd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKortestq<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kortestq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKortestw<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kortestw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKorw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn korw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftlb<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

Source§

fn kshiftlb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftlb<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

Source§

fn kshiftlb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftld<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

Source§

fn kshiftld( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftld<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

Source§

fn kshiftld( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftlq<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

Source§

fn kshiftlq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftlq<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

Source§

fn kshiftlq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftlw<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

Source§

fn kshiftlw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftlw<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

Source§

fn kshiftlw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftrb<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

Source§

fn kshiftrb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftrb<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

Source§

fn kshiftrb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftrd<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

Source§

fn kshiftrd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftrd<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

Source§

fn kshiftrd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftrq<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

Source§

fn kshiftrq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftrq<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

Source§

fn kshiftrq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftrw<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

Source§

fn kshiftrw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKshiftrw<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

Source§

fn kshiftrw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmKtestb<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn ktestb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKtestd<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn ktestd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKtestq<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn ktestq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKtestw<AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn ktestw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKunpckbw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kunpckbw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKunpckdq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kunpckdq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKunpckwd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kunpckwd( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKxnorb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kxnorb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKxnord<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kxnord( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKxnorq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kxnorq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKxnorw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kxnorw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKxorb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kxorb( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKxord<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kxord( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKxorq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kxorq( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmKxorw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

Source§

fn kxorw( &mut self, op0: AsmRegisterK, op1: AsmRegisterK, op2: AsmRegisterK, ) -> Result<(), IcedError>

Source§

impl CodeAsmLahf for CodeAssembler

Source§

fn lahf(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmLar<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn lar( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLar<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn lar( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmLar<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn lar( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLar<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn lar( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLar<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn lar( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmLddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLdmxcsr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLds<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn lds( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLds<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn lds( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLdtilecfg<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLea<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn lea( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLea<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn lea( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLea<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn lea( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLeave for CodeAssembler

Source§

fn leave(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmLes<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn les( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLes<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn les( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLfence for CodeAssembler

Source§

fn lfence(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmLfs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn lfs( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLfs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn lfs( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLfs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn lfs( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLgdt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLgs<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn lgs( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLgs<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn lgs( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLgs<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn lgs( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLidt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLkgs<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLkgs<AsmRegister16> for CodeAssembler

Source§

fn lkgs(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmLkgs<AsmRegister32> for CodeAssembler

Source§

fn lkgs(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmLkgs<AsmRegister64> for CodeAssembler

Source§

fn lkgs(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmLldt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLldt<AsmRegister16> for CodeAssembler

Source§

fn lldt(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmLldt<AsmRegister32> for CodeAssembler

Source§

fn lldt(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmLldt<AsmRegister64> for CodeAssembler

Source§

fn lldt(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmLlwpcb<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmLlwpcb<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmLmsw<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLmsw<AsmRegister16> for CodeAssembler

Source§

fn lmsw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmLmsw<AsmRegister32> for CodeAssembler

Source§

fn lmsw(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmLmsw<AsmRegister64> for CodeAssembler

Source§

fn lmsw(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmLoadall for CodeAssembler

Source§

fn loadall(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmLoadiwkey<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmLodsb for CodeAssembler

Source§

fn lodsb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmLodsd for CodeAssembler

Source§

fn lodsd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmLodsq for CodeAssembler

Source§

fn lodsq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmLodsw for CodeAssembler

Source§

fn lodsw(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmLoop<CodeLabel> for CodeAssembler

Source§

fn loop_(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmLoop<u64> for CodeAssembler

Source§

fn loop_(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmLoope<CodeLabel> for CodeAssembler

Source§

fn loope(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmLoope<u64> for CodeAssembler

Source§

fn loope(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmLoopne<CodeLabel> for CodeAssembler

Source§

fn loopne(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmLoopne<u64> for CodeAssembler

Source§

fn loopne(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmLoopnz<CodeLabel> for CodeAssembler

Source§

fn loopnz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmLoopnz<u64> for CodeAssembler

Source§

fn loopnz(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmLoopz<CodeLabel> for CodeAssembler

Source§

fn loopz(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmLoopz<u64> for CodeAssembler

Source§

fn loopz(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmLsl<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn lsl( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLsl<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn lsl( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmLsl<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn lsl( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLsl<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn lsl( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLsl<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn lsl( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmLss<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn lss( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLss<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn lss( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLss<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn lss( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmLtr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLtr<AsmRegister16> for CodeAssembler

Source§

fn ltr(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmLtr<AsmRegister32> for CodeAssembler

Source§

fn ltr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmLtr<AsmRegister64> for CodeAssembler

Source§

fn ltr(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmLwpins<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn lwpins( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpins<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn lwpins( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpins<AsmRegister32, AsmRegister32, i32> for CodeAssembler

Source§

fn lwpins( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpins<AsmRegister32, AsmRegister32, u32> for CodeAssembler

Source§

fn lwpins( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpins<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn lwpins( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpins<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn lwpins( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpins<AsmRegister64, AsmRegister32, i32> for CodeAssembler

Source§

fn lwpins( &mut self, op0: AsmRegister64, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpins<AsmRegister64, AsmRegister32, u32> for CodeAssembler

Source§

fn lwpins( &mut self, op0: AsmRegister64, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpval<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn lwpval( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpval<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn lwpval( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpval<AsmRegister32, AsmRegister32, i32> for CodeAssembler

Source§

fn lwpval( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpval<AsmRegister32, AsmRegister32, u32> for CodeAssembler

Source§

fn lwpval( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpval<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn lwpval( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpval<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn lwpval( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpval<AsmRegister64, AsmRegister32, i32> for CodeAssembler

Source§

fn lwpval( &mut self, op0: AsmRegister64, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLwpval<AsmRegister64, AsmRegister32, u32> for CodeAssembler

Source§

fn lwpval( &mut self, op0: AsmRegister64, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLzcnt<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn lzcnt( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmLzcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLzcnt<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn lzcnt( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmLzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmLzcnt<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn lzcnt( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmMaskmovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMaskmovq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmMaxpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMaxpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn maxpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMaxps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMaxps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn maxps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMaxsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn maxsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMaxss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMaxss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn maxss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMcommit for CodeAssembler

Source§

fn mcommit(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMfence for CodeAssembler

Source§

fn mfence(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMinpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMinpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn minpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMinps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMinps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn minps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMinsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMinsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn minsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMinss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMinss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn minss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMonitor for CodeAssembler

Source§

fn monitor(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMonitorx for CodeAssembler

Source§

fn monitorx(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMontmul for CodeAssembler

Source§

fn montmul(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmMemoryOperand, AsmRegisterSegment> for CodeAssembler

Source§

impl CodeAsmMov<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister16, AsmRegisterSegment> for CodeAssembler

Source§

impl CodeAsmMov<AsmRegister16, i32> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister16, u32> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister32, AsmRegisterCr> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister32, op1: AsmRegisterCr, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister32, AsmRegisterDr> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister32, op1: AsmRegisterDr, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister32, AsmRegisterSegment> for CodeAssembler

Source§

impl CodeAsmMov<AsmRegister32, AsmRegisterTr> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister32, op1: AsmRegisterTr, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister32, i32> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister32, u32> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister64, AsmRegisterCr> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister64, op1: AsmRegisterCr, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister64, AsmRegisterDr> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister64, op1: AsmRegisterDr, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister64, AsmRegisterSegment> for CodeAssembler

Source§

impl CodeAsmMov<AsmRegister64, i64> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmRegister64, op1: i64) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister64, u64> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmRegister64, op1: u64) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister8, i32> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegister8, u32> for CodeAssembler

Source§

fn mov(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegisterCr, AsmRegister32> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegisterCr, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegisterCr, AsmRegister64> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegisterCr, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegisterDr, AsmRegister32> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegisterDr, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegisterDr, AsmRegister64> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegisterDr, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmMov<AsmRegisterSegment, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMov<AsmRegisterSegment, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmMov<AsmRegisterSegment, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmMov<AsmRegisterSegment, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmMov<AsmRegisterTr, AsmRegister32> for CodeAssembler

Source§

fn mov( &mut self, op0: AsmRegisterTr, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovapd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovapd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovapd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovaps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovaps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovaps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmMovbe<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmMovbe<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovbe<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovbe<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

Source§

fn movd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovd<AsmRegister32, AsmRegisterMm> for CodeAssembler

Source§

fn movd( &mut self, op0: AsmRegister32, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

fn movd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

fn movd( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovd<AsmRegisterMm, AsmRegister32> for CodeAssembler

Source§

fn movd( &mut self, op0: AsmRegisterMm, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

fn movd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovddup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovdir64b<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovdir64b<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovdir64b<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmMovdiri<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmMovdq2q<AsmRegisterMm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovdqa<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovdqa<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovdqu<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovdqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovhlps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovhpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovhpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovhps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovhps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovlhps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovlpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovlpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovlps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovlps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovmskpd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovmskpd<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovmskps<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovmskps<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmMovnti<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmMovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovntq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmMovntsd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovntss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterMm> for CodeAssembler

Source§

fn movq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovq<AsmRegister64, AsmRegisterMm> for CodeAssembler

Source§

fn movq( &mut self, op0: AsmRegister64, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovq<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

fn movq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

fn movq( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovq<AsmRegisterMm, AsmRegister64> for CodeAssembler

Source§

fn movq( &mut self, op0: AsmRegisterMm, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn movq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

fn movq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn movq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovq2dq<AsmRegisterXmm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmMovsb for CodeAssembler

Source§

fn movsb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMovsd for CodeAssembler

Source§

fn movsd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMovsd2<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovsd2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovsd2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovshdup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovsldup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovsq for CodeAssembler

Source§

fn movsq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMovss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn movss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovsw for CodeAssembler

Source§

fn movsw(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMovsx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovsx<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn movsx( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovsx<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn movsx( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovsx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovsx<AsmRegister32, AsmRegister16> for CodeAssembler

Source§

fn movsx( &mut self, op0: AsmRegister32, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovsx<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn movsx( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovsx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovsx<AsmRegister64, AsmRegister16> for CodeAssembler

Source§

fn movsx( &mut self, op0: AsmRegister64, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovsx<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn movsx( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovsxd<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovsxd<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn movsxd( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovsxd<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovsxd<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn movsxd( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovsxd<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovsxd<AsmRegister64, AsmRegister32> for CodeAssembler

Source§

fn movsxd( &mut self, op0: AsmRegister64, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovupd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovupd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovupd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovups<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovups<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovups<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmMovzx<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovzx<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn movzx( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovzx<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn movzx( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovzx<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovzx<AsmRegister32, AsmRegister16> for CodeAssembler

Source§

fn movzx( &mut self, op0: AsmRegister32, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovzx<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn movzx( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovzx<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMovzx<AsmRegister64, AsmRegister16> for CodeAssembler

Source§

fn movzx( &mut self, op0: AsmRegister64, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmMovzx<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn movzx( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn mpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn mpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn mpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMpsadbw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn mpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMul<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMul<AsmRegister16> for CodeAssembler

Source§

fn mul(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmMul<AsmRegister32> for CodeAssembler

Source§

fn mul(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmMul<AsmRegister64> for CodeAssembler

Source§

fn mul(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmMul<AsmRegister8> for CodeAssembler

Source§

fn mul(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmMulpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMulpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn mulpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMulps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMulps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn mulps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMulsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMulsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn mulsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMulss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMulss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn mulss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmMulx<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMulx<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn mulx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmMulx<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmMulx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn mulx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmMwait for CodeAssembler

Source§

fn mwait(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmMwaitx for CodeAssembler

Source§

fn mwaitx(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmNeg<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmNeg<AsmRegister16> for CodeAssembler

Source§

fn neg(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmNeg<AsmRegister32> for CodeAssembler

Source§

fn neg(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmNeg<AsmRegister64> for CodeAssembler

Source§

fn neg(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmNeg<AsmRegister8> for CodeAssembler

Source§

fn neg(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmNop for CodeAssembler

Source§

fn nop(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmNop1<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmNop1<AsmRegister16> for CodeAssembler

Source§

fn nop_1(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmNop1<AsmRegister32> for CodeAssembler

Source§

fn nop_1(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmNop1<AsmRegister64> for CodeAssembler

Source§

fn nop_1(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmNot<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmNot<AsmRegister16> for CodeAssembler

Source§

fn not(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmNot<AsmRegister32> for CodeAssembler

Source§

fn not(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmNot<AsmRegister64> for CodeAssembler

Source§

fn not(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmNot<AsmRegister8> for CodeAssembler

Source§

fn not(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn or( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn or( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn or( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn or( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn or(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn or(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn or( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn or( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister16, i32> for CodeAssembler

Source§

fn or(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister16, u32> for CodeAssembler

Source§

fn or(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn or( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn or( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister32, i32> for CodeAssembler

Source§

fn or(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister32, u32> for CodeAssembler

Source§

fn or(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn or( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn or( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister64, i32> for CodeAssembler

Source§

fn or(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn or( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn or(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister8, i32> for CodeAssembler

Source§

fn or(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmOr<AsmRegister8, u32> for CodeAssembler

Source§

fn or(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmOrpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmOrpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn orpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmOrps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmOrps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn orps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmOut<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn out( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmOut<AsmRegister16, AsmRegister32> for CodeAssembler

Source§

fn out( &mut self, op0: AsmRegister16, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmOut<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn out( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmOut<i32, AsmRegister16> for CodeAssembler

Source§

fn out(&mut self, op0: i32, op1: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmOut<i32, AsmRegister32> for CodeAssembler

Source§

fn out(&mut self, op0: i32, op1: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmOut<i32, AsmRegister8> for CodeAssembler

Source§

fn out(&mut self, op0: i32, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmOut<u32, AsmRegister16> for CodeAssembler

Source§

fn out(&mut self, op0: u32, op1: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmOut<u32, AsmRegister32> for CodeAssembler

Source§

fn out(&mut self, op0: u32, op1: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmOut<u32, AsmRegister8> for CodeAssembler

Source§

fn out(&mut self, op0: u32, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmOutsb for CodeAssembler

Source§

fn outsb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmOutsd for CodeAssembler

Source§

fn outsd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmOutsw for CodeAssembler

Source§

fn outsw(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPabsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPabsb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pabsb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPabsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn pabsb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPabsd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPabsd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pabsd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPabsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn pabsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPabsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPabsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pabsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPabsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn pabsw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPackssdw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPackssdw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPackssdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPackssdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPacksswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPacksswb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPacksswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPacksswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPackusdw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPackusdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPackuswb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPackuswb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPackuswb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPackuswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPaddb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paddb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn paddb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paddd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn paddd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paddq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn paddq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddsb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paddsb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPaddsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddsiw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paddsiw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paddsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPaddusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddusb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paddusb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddusb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPaddusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddusw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paddusw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddusw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paddw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaddw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn paddw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn palignr( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPalignr<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn palignr( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPalignr<AsmRegisterMm, AsmRegisterMm, i32> for CodeAssembler

Source§

fn palignr( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPalignr<AsmRegisterMm, AsmRegisterMm, u32> for CodeAssembler

Source§

fn palignr( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPalignr<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn palignr( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPalignr<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn palignr( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPalignr<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn palignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPalignr<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn palignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPand<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

fn pand( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmPand<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pand( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPand<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPand<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn pand( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPandn<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPandn<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pandn( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPandn<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPandn<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn pandn( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPause for CodeAssembler

Source§

fn pause(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPaveb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPaveb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn paveb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPavgb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPavgb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pavgb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPavgb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPavgb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn pavgb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPavgusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPavgusb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pavgusb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPavgw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPavgw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pavgw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPavgw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPavgw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn pavgw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPblendvb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPblendvb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPblendw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pblendw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPblendw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pblendw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPblendw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPblendw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPbndkb for CodeAssembler

Source§

fn pbndkb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPclmulhqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPclmulhqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPclmullqhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPclmullqlqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPclmulqdq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pclmulqdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpeqb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpeqb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pcmpeqb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpeqb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpeqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPcmpeqd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpeqd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pcmpeqd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpeqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpeqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPcmpeqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpeqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPcmpeqw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpeqw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pcmpeqw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpeqw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpeqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestri64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpgtb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpgtb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pcmpgtb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpgtb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpgtb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPcmpgtd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpgtd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pcmpgtd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpgtd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpgtd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPcmpgtq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpgtq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPcmpgtw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpgtw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pcmpgtw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpgtw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPcmpgtw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpistri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcmpistrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPcommit for CodeAssembler

Source§

fn pcommit(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPconfig for CodeAssembler

Source§

fn pconfig(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPdep<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPdep<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn pdep( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPdep<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPdep<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn pdep( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmPdistib<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPext<AsmRegister32, AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPext<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn pext( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPext<AsmRegister64, AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPext<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn pext( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrb<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrb<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrb<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrb<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrb<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrb<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrd<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrd<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrd<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrd<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrq<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrq<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrq<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrq<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmRegister32, AsmRegisterMm, i32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterMm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmRegister32, AsmRegisterMm, u32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterMm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmRegister64, AsmRegisterMm, i32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterMm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmRegister64, AsmRegisterMm, u32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterMm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPextrw<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPf2id<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPf2id<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pf2id( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPf2iw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPf2iw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pf2iw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfacc<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfacc( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfadd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfadd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfadd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfcmpeq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfcmpeq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfcmpeq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfcmpge<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfcmpge<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfcmpge( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfcmpgt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfcmpgt<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfcmpgt( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfmax<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfmax<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfmax( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfmin<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfmin<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfmin( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfmul<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfmul<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfmul( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfnacc<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfnacc( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfpnacc<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfpnacc<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfpnacc( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfrcp<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfrcp<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfrcp( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfrcpit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfrcpit1<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPfrcpit2<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfrcpit2<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPfrcpv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfrcpv<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfrcpv( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfrsqit1<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfrsqit1<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPfrsqrt<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfrsqrt<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfrsqrt( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfrsqrtv<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfrsqrtv<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPfsub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfsub<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfsub( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPfsubr<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPfsubr<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pfsubr( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPhaddd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhaddd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn phaddd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPhaddd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhaddd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPhaddsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhaddsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn phaddsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPhaddsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhaddsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPhaddw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhaddw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn phaddw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPhaddw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhaddw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPhminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhminposuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPhsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhsubd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn phsubd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPhsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhsubd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPhsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhsubsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn phsubsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPhsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhsubsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPhsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhsubw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn phsubw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPhsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPhsubw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPi2fd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPi2fd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pi2fd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPi2fw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPi2fw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pi2fw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

Source§

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

Source§

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

Source§

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrb<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

Source§

fn pinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrd<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

Source§

fn pinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrd<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

Source§

fn pinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrq<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

Source§

fn pinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrq<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

Source§

fn pinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister32, i32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister32, u32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister64, i32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterMm, AsmRegister64, u32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterMm, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPinsrw<AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

Source§

fn pinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmachriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaddubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaddubsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPmaddubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaddubsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmaddwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaddwd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pmaddwd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaddwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmagw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmagw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pmagw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmaxsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaxsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmaxsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaxsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmaxsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaxsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pmaxsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmaxsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaxsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmaxub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaxub<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pmaxub( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmaxub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaxub<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmaxud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaxud<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmaxuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmaxuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPminsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPminsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPminsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPminsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPminsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPminsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pminsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPminsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPminsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPminub<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPminub<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pminub( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPminub<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPminub<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPminud<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPminud<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPminuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPminuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovmskb<AsmRegister32, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPmovmskb<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovmskb<AsmRegister64, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPmovmskb<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovsxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovsxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovsxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovsxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovsxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovsxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovzxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovzxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovzxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovzxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovzxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmovzxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmuldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmuldq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmulhriw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulhriw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPmulhrsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulhrsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPmulhrsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulhrsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmulhrw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulhrw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pmulhrw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmulhrw_cyrix<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulhrw_cyrix<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPmulhuw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulhuw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pmulhuw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmulhuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulhuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmulhw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulhw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pmulhw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmulhw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulhw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmulld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmulld<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmullw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmullw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pmullw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmullw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmullw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmuludq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmuludq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pmuludq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPmuludq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmuludq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPmvgezb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmvlzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmvnzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPmvzb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPop<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPop<AsmRegister16> for CodeAssembler

Source§

fn pop(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmPop<AsmRegister32> for CodeAssembler

Source§

fn pop(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmPop<AsmRegister64> for CodeAssembler

Source§

fn pop(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmPop<AsmRegisterSegment> for CodeAssembler

Source§

impl CodeAsmPopa for CodeAssembler

Source§

fn popa(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPopad for CodeAssembler

Source§

fn popad(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPopcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPopcnt<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn popcnt( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmPopcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPopcnt<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn popcnt( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPopcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPopcnt<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn popcnt( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmPopf for CodeAssembler

Source§

fn popf(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPopfd for CodeAssembler

Source§

fn popfd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPopfq for CodeAssembler

Source§

fn popfq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

fn por( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmPor<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn por( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

fn por( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmPor<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn por( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPrefetch<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPrefetchit0<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPrefetchit1<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPrefetchnta<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPrefetcht0<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPrefetcht1<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPrefetcht2<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPrefetchw<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPrefetchwt1<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsadbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsadbw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psadbw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsadbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsadbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPshufb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPshufb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pshufb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPshufb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPshufd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufhw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufhw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufhw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufhw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshuflw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshuflw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshuflw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshuflw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn pshufw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufw<AsmRegisterMm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn pshufw( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufw<AsmRegisterMm, AsmRegisterMm, i32> for CodeAssembler

Source§

fn pshufw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPshufw<AsmRegisterMm, AsmRegisterMm, u32> for CodeAssembler

Source§

fn pshufw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsignb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsignb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psignb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsignb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsignb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPsignd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsignd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psignd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsignd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsignd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPsignw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsignw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psignw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsignw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsignw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPslld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPslld<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pslld( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPslld<AsmRegisterMm, i32> for CodeAssembler

Source§

fn pslld(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPslld<AsmRegisterMm, u32> for CodeAssembler

Source§

fn pslld(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPslld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPslld<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn pslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPslld<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pslld(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPslld<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pslld(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPslldq<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn pslldq(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPslldq<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn pslldq(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsllq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsllq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psllq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsllq<AsmRegisterMm, i32> for CodeAssembler

Source§

fn psllq(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsllq<AsmRegisterMm, u32> for CodeAssembler

Source§

fn psllq(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsllq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsllq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsllq<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn psllq(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsllq<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn psllq(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsllw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsllw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psllw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsllw<AsmRegisterMm, i32> for CodeAssembler

Source§

fn psllw(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsllw<AsmRegisterMm, u32> for CodeAssembler

Source§

fn psllw(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsllw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsllw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsllw<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn psllw(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsllw<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn psllw(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsmash for CodeAssembler

Source§

fn psmash(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPsrad<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsrad<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psrad( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsrad<AsmRegisterMm, i32> for CodeAssembler

Source§

fn psrad(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrad<AsmRegisterMm, u32> for CodeAssembler

Source§

fn psrad(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrad<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsrad<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsrad<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn psrad(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrad<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn psrad(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsraw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsraw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psraw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsraw<AsmRegisterMm, i32> for CodeAssembler

Source§

fn psraw(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsraw<AsmRegisterMm, u32> for CodeAssembler

Source§

fn psraw(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsraw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsraw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsraw<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn psraw(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsraw<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn psraw(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrld<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsrld<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psrld( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsrld<AsmRegisterMm, i32> for CodeAssembler

Source§

fn psrld(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrld<AsmRegisterMm, u32> for CodeAssembler

Source§

fn psrld(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrld<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsrld<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsrld<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn psrld(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrld<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn psrld(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrldq<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn psrldq(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrldq<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn psrldq(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsrlq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psrlq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlq<AsmRegisterMm, i32> for CodeAssembler

Source§

fn psrlq(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlq<AsmRegisterMm, u32> for CodeAssembler

Source§

fn psrlq(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsrlq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlq<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn psrlq(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlq<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn psrlq(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsrlw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psrlw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlw<AsmRegisterMm, i32> for CodeAssembler

Source§

fn psrlw(&mut self, op0: AsmRegisterMm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlw<AsmRegisterMm, u32> for CodeAssembler

Source§

fn psrlw(&mut self, op0: AsmRegisterMm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsrlw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlw<AsmRegisterXmm, i32> for CodeAssembler

Source§

fn psrlw(&mut self, op0: AsmRegisterXmm, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPsrlw<AsmRegisterXmm, u32> for CodeAssembler

Source§

fn psrlw(&mut self, op0: AsmRegisterXmm, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPsubb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psubb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psubb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psubd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psubd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psubq( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psubq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubsb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubsb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psubsb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPsubsiw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubsiw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psubsiw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubsw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubsw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psubsw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPsubusb<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubusb<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psubusb( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubusb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubusb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPsubusw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubusw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psubusw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubusw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubusw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPsubw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn psubw( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPsubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPsubw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn psubw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPswapd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPswapd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pswapd( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPtest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPtest<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn ptest( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPtwrite<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPtwrite<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmPtwrite<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmPunpckhbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpckhbw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPunpckhbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpckhbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPunpckhdq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpckhdq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPunpckhdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpckhdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPunpckhqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpckhqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPunpckhwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpckhwd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPunpckhwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpckhwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPunpcklbw<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpcklbw<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPunpcklbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpcklbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPunpckldq<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpckldq<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPunpckldq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpckldq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPunpcklqdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpcklqdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPunpcklwd<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpcklwd<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

impl CodeAsmPunpcklwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPunpcklwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmPush<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPush<AsmRegister16> for CodeAssembler

Source§

fn push(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmPush<AsmRegister32> for CodeAssembler

Source§

fn push(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmPush<AsmRegister64> for CodeAssembler

Source§

fn push(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmPush<AsmRegisterSegment> for CodeAssembler

Source§

impl CodeAsmPush<i32> for CodeAssembler

Source§

fn push(&mut self, op0: i32) -> Result<(), IcedError>

Source§

impl CodeAsmPush<u32> for CodeAssembler

Source§

fn push(&mut self, op0: u32) -> Result<(), IcedError>

Source§

impl CodeAsmPusha for CodeAssembler

Source§

fn pusha(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPushad for CodeAssembler

Source§

fn pushad(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPushf for CodeAssembler

Source§

fn pushf(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPushfd for CodeAssembler

Source§

fn pushfd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPushfq for CodeAssembler

Source§

fn pushfq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmPvalidate for CodeAssembler

Source§

impl CodeAsmPxor<AsmRegisterMm, AsmMemoryOperand> for CodeAssembler

Source§

fn pxor( &mut self, op0: AsmRegisterMm, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmPxor<AsmRegisterMm, AsmRegisterMm> for CodeAssembler

Source§

fn pxor( &mut self, op0: AsmRegisterMm, op1: AsmRegisterMm, ) -> Result<(), IcedError>

Source§

impl CodeAsmPxor<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmPxor<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn pxor( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn rcl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn rcl( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister16, i32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister16, u32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn rcl( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister32, i32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister32, u32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn rcl( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister64, i32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister64, u32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister8, i32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcl<AsmRegister8, u32> for CodeAssembler

Source§

fn rcl(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmRcpps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn rcpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcpss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmRcpss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn rcpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn rcr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn rcr( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister16, i32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister16, u32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn rcr( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister32, i32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister32, u32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn rcr( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister64, i32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister64, u32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister8, i32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRcr<AsmRegister8, u32> for CodeAssembler

Source§

fn rcr(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRdfsbase<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmRdfsbase<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmRdgsbase<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmRdgsbase<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmRdm for CodeAssembler

Source§

fn rdm(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRdmsr for CodeAssembler

Source§

fn rdmsr(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRdmsrlist for CodeAssembler

Source§

impl CodeAsmRdpid<AsmRegister32> for CodeAssembler

Source§

fn rdpid(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmRdpid<AsmRegister64> for CodeAssembler

Source§

fn rdpid(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmRdpkru for CodeAssembler

Source§

fn rdpkru(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRdpmc for CodeAssembler

Source§

fn rdpmc(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRdpru for CodeAssembler

Source§

fn rdpru(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRdrand<AsmRegister16> for CodeAssembler

Source§

impl CodeAsmRdrand<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmRdrand<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmRdseed<AsmRegister16> for CodeAssembler

Source§

impl CodeAsmRdseed<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmRdseed<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmRdshr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmRdshr<AsmRegister32> for CodeAssembler

Source§

fn rdshr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmRdsspd<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmRdsspq<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmRdtsc for CodeAssembler

Source§

fn rdtsc(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRdtscp for CodeAssembler

Source§

fn rdtscp(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRdudbg for CodeAssembler

Source§

fn rdudbg(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f0d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f0d<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f0d<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f0d<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f18<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f18<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f18<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f18<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f19<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f19<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f19<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f19<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1a<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1a<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1a<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1a<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1b<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1b<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1b<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1b<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1c<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1c<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1c<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1c<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1d<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1d<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1d<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1d<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1e<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1e<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1e<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1e<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1f<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1f<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1f<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmReservednop_0f1f<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmRet for CodeAssembler

Source§

fn ret(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRet1<i32> for CodeAssembler

Source§

fn ret_1(&mut self, op0: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRet1<u32> for CodeAssembler

Source§

fn ret_1(&mut self, op0: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRetf for CodeAssembler

Source§

fn retf(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRetf1<i32> for CodeAssembler

Source§

fn retf_1(&mut self, op0: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRetf1<u32> for CodeAssembler

Source§

fn retf_1(&mut self, op0: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRmpadjust for CodeAssembler

Source§

impl CodeAsmRmpquery for CodeAssembler

Source§

fn rmpquery(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRmpupdate for CodeAssembler

Source§

impl CodeAsmRol<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn rol( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn rol( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister16, i32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister16, u32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn rol( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister32, i32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister32, u32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn rol( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister64, i32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister64, u32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister8, i32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRol<AsmRegister8, u32> for CodeAssembler

Source§

fn rol(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn ror( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn ror( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister16, i32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister16, u32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn ror( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister32, i32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister32, u32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn ror( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister64, i32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister64, u32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister8, i32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmRor<AsmRegister8, u32> for CodeAssembler

Source§

fn ror(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmRorx<AsmRegister32, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn rorx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRorx<AsmRegister32, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn rorx( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRorx<AsmRegister32, AsmRegister32, i32> for CodeAssembler

Source§

fn rorx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRorx<AsmRegister32, AsmRegister32, u32> for CodeAssembler

Source§

fn rorx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRorx<AsmRegister64, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn rorx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRorx<AsmRegister64, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn rorx( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRorx<AsmRegister64, AsmRegister64, i32> for CodeAssembler

Source§

fn rorx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRorx<AsmRegister64, AsmRegister64, u32> for CodeAssembler

Source§

fn rorx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn roundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn roundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn roundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn roundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn roundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn roundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn roundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn roundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundsd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn roundsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundsd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn roundsd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundsd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn roundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundsd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn roundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundss<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn roundss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundss<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn roundss( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundss<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn roundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRoundss<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn roundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmRsdc<AsmRegisterSegment, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmRsldt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmRsm for CodeAssembler

Source§

fn rsm(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmRsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmRsqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmRsqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmRsqrtss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmRstorssp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmRsts<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSahf for CodeAssembler

Source§

fn sahf(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn sal( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn sal( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister16, i32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister16, u32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn sal( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister32, i32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister32, u32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn sal( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister64, i32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister64, u32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister8, i32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSal<AsmRegister8, u32> for CodeAssembler

Source§

fn sal(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSalc for CodeAssembler

Source§

fn salc(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn sar( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn sar( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister16, i32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister16, u32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn sar( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister32, i32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister32, u32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn sar( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister64, i32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister64, u32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister8, i32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSar<AsmRegister8, u32> for CodeAssembler

Source§

fn sar(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSarx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmSarx<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn sarx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSarx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmSarx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn sarx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmSaveprevssp for CodeAssembler

Source§

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister16, i32> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister16, u32> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister32, i32> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister32, u32> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister64, i32> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn sbb( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister8, i32> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSbb<AsmRegister8, u32> for CodeAssembler

Source§

fn sbb(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmScasb for CodeAssembler

Source§

fn scasb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmScasd for CodeAssembler

Source§

fn scasd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmScasq for CodeAssembler

Source§

fn scasq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmScasw for CodeAssembler

Source§

fn scasw(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSeamcall for CodeAssembler

Source§

fn seamcall(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSeamops for CodeAssembler

Source§

fn seamops(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSeamret for CodeAssembler

Source§

fn seamret(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSenduipi<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmSerialize for CodeAssembler

Source§

impl CodeAsmSeta<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSeta<AsmRegister8> for CodeAssembler

Source§

fn seta(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetae<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetae<AsmRegister8> for CodeAssembler

Source§

fn setae(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetb<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetb<AsmRegister8> for CodeAssembler

Source§

fn setb(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetbe<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetbe<AsmRegister8> for CodeAssembler

Source§

fn setbe(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetc<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetc<AsmRegister8> for CodeAssembler

Source§

fn setc(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSete<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSete<AsmRegister8> for CodeAssembler

Source§

fn sete(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetg<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetg<AsmRegister8> for CodeAssembler

Source§

fn setg(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetge<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetge<AsmRegister8> for CodeAssembler

Source§

fn setge(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetl<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetl<AsmRegister8> for CodeAssembler

Source§

fn setl(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetle<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetle<AsmRegister8> for CodeAssembler

Source§

fn setle(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetna<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetna<AsmRegister8> for CodeAssembler

Source§

fn setna(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetnae<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetnae<AsmRegister8> for CodeAssembler

Source§

fn setnae(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetnb<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetnb<AsmRegister8> for CodeAssembler

Source§

fn setnb(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetnbe<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetnbe<AsmRegister8> for CodeAssembler

Source§

fn setnbe(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetnc<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetnc<AsmRegister8> for CodeAssembler

Source§

fn setnc(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetne<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetne<AsmRegister8> for CodeAssembler

Source§

fn setne(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetng<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetng<AsmRegister8> for CodeAssembler

Source§

fn setng(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetnge<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetnge<AsmRegister8> for CodeAssembler

Source§

fn setnge(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetnl<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetnl<AsmRegister8> for CodeAssembler

Source§

fn setnl(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetnle<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetnle<AsmRegister8> for CodeAssembler

Source§

fn setnle(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetno<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetno<AsmRegister8> for CodeAssembler

Source§

fn setno(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetnp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetnp<AsmRegister8> for CodeAssembler

Source§

fn setnp(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetns<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetns<AsmRegister8> for CodeAssembler

Source§

fn setns(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetnz<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetnz<AsmRegister8> for CodeAssembler

Source§

fn setnz(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSeto<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSeto<AsmRegister8> for CodeAssembler

Source§

fn seto(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetp<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetp<AsmRegister8> for CodeAssembler

Source§

fn setp(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetpe<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetpe<AsmRegister8> for CodeAssembler

Source§

fn setpe(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetpo<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetpo<AsmRegister8> for CodeAssembler

Source§

fn setpo(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSets<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSets<AsmRegister8> for CodeAssembler

Source§

fn sets(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSetssbsy for CodeAssembler

Source§

fn setssbsy(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSetz<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSetz<AsmRegister8> for CodeAssembler

Source§

fn setz(&mut self, op0: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSfence for CodeAssembler

Source§

fn sfence(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSgdt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSha1msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSha1msg1<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmSha1msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSha1msg2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmSha1nexte<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSha1nexte<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn sha1rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn sha1rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn sha1rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSha1rnds4<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn sha1rnds4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSha256msg1<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSha256msg1<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmSha256msg2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSha256msg2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmSha256rnds2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSha256rnds2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmShl<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn shl( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn shl( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister16, i32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister16, u32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn shl( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister32, i32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister32, u32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn shl( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister64, i32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister64, u32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister8, i32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShl<AsmRegister8, u32> for CodeAssembler

Source§

fn shl(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

Source§

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, AsmRegister8> for CodeAssembler

Source§

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, i32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmMemoryOperand, AsmRegister32, u32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, AsmRegister8> for CodeAssembler

Source§

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, i32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmMemoryOperand, AsmRegister64, u32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmRegister16, AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmRegister16, AsmRegister16, i32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmRegister16, AsmRegister16, u32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmRegister32, AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmRegister32, AsmRegister32, i32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmRegister32, AsmRegister32, u32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmRegister64, AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmRegister64, AsmRegister64, i32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShld<AsmRegister64, AsmRegister64, u32> for CodeAssembler

Source§

fn shld( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShlx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmShlx<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn shlx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShlx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmShlx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn shlx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn shr( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn shr( &mut self, op0: AsmRegister16, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister16, i32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister16, u32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn shr( &mut self, op0: AsmRegister32, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister32, i32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister32, u32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn shr( &mut self, op0: AsmRegister64, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister64, i32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister64, u32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmRegister64, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister8, i32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmShr<AsmRegister8, u32> for CodeAssembler

Source§

fn shr(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, AsmRegister8> for CodeAssembler

Source§

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, i32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister16, u32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, AsmRegister8> for CodeAssembler

Source§

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, i32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister32, u32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, AsmRegister8> for CodeAssembler

Source§

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, i32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmMemoryOperand, AsmRegister64, u32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmRegister16, AsmRegister16, AsmRegister8> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmRegister16, AsmRegister16, i32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmRegister16, AsmRegister16, u32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmRegister16, op1: AsmRegister16, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmRegister32, AsmRegister32, AsmRegister8> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmRegister32, AsmRegister32, i32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmRegister32, AsmRegister32, u32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmRegister64, AsmRegister64, AsmRegister8> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmRegister64, AsmRegister64, i32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrd<AsmRegister64, AsmRegister64, u32> for CodeAssembler

Source§

fn shrd( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrx<AsmRegister32, AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmShrx<AsmRegister32, AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn shrx( &mut self, op0: AsmRegister32, op1: AsmRegister32, op2: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShrx<AsmRegister64, AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmShrx<AsmRegister64, AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn shrx( &mut self, op0: AsmRegister64, op1: AsmRegister64, op2: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShufpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShufpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShufpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn shufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShufps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn shufps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShufps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn shufps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShufps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn shufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmShufps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn shufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSidt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSkinit for CodeAssembler

Source§

fn skinit(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSldt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSldt<AsmRegister16> for CodeAssembler

Source§

fn sldt(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmSldt<AsmRegister32> for CodeAssembler

Source§

fn sldt(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmSldt<AsmRegister64> for CodeAssembler

Source§

fn sldt(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmSlwpcb<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmSlwpcb<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmSmint for CodeAssembler

Source§

fn smint(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSmint_0f7e for CodeAssembler

Source§

impl CodeAsmSmsw<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSmsw<AsmRegister16> for CodeAssembler

Source§

fn smsw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmSmsw<AsmRegister32> for CodeAssembler

Source§

fn smsw(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmSmsw<AsmRegister64> for CodeAssembler

Source§

fn smsw(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmSqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSqrtpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmSqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmSqrtsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSqrtsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmSqrtss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSqrtss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmStac for CodeAssembler

Source§

fn stac(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmStc for CodeAssembler

Source§

fn stc(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmStd for CodeAssembler

Source§

fn std(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmStgi for CodeAssembler

Source§

fn stgi(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSti for CodeAssembler

Source§

fn sti(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmStmxcsr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmStosb for CodeAssembler

Source§

fn stosb(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmStosd for CodeAssembler

Source§

fn stosd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmStosq for CodeAssembler

Source§

fn stosq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmStosw for CodeAssembler

Source§

fn stosw(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmStr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmStr<AsmRegister16> for CodeAssembler

Source§

fn str(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmStr<AsmRegister32> for CodeAssembler

Source§

fn str(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmStr<AsmRegister64> for CodeAssembler

Source§

fn str(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmSttilecfg<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmStui for CodeAssembler

Source§

fn stui(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister16, i32> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister16, u32> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister32, i32> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister32, u32> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister64, i32> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn sub( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister8, i32> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmSub<AsmRegister8, u32> for CodeAssembler

Source§

fn sub(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmSubpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSubpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn subpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmSubps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSubps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn subps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmSubsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSubsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn subsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmSubss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSubss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn subss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmSvdc<AsmMemoryOperand, AsmRegisterSegment> for CodeAssembler

Source§

impl CodeAsmSvldt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSvts<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmSwapgs for CodeAssembler

Source§

fn swapgs(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSyscall for CodeAssembler

Source§

fn syscall(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSysenter for CodeAssembler

Source§

fn sysenter(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSysexit for CodeAssembler

Source§

fn sysexit(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSysexitq for CodeAssembler

Source§

fn sysexitq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSysret for CodeAssembler

Source§

fn sysret(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmSysretq for CodeAssembler

Source§

fn sysretq(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmT1mskc<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmT1mskc<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn t1mskc( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmT1mskc<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmT1mskc<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn t1mskc( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmTcmmimfp16ps<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTcmmrlfp16ps<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTdcall for CodeAssembler

Source§

fn tdcall(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmTdpbf16ps<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTdpbssd<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTdpbsud<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTdpbusd<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTdpbuud<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTdpfp16ps<AsmRegisterTmm, AsmRegisterTmm, AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTest<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn test( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn test(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn test(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn test( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister16, i32> for CodeAssembler

Source§

fn test(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister16, u32> for CodeAssembler

Source§

fn test(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn test( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister32, i32> for CodeAssembler

Source§

fn test(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister32, u32> for CodeAssembler

Source§

fn test(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn test( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister64, i32> for CodeAssembler

Source§

fn test(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn test( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister8, i32> for CodeAssembler

Source§

fn test(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmTest<AsmRegister8, u32> for CodeAssembler

Source§

fn test(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmTestui for CodeAssembler

Source§

fn testui(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmTileloadd<AsmRegisterTmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmTileloaddt1<AsmRegisterTmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmTilerelease for CodeAssembler

Source§

impl CodeAsmTilestored<AsmMemoryOperand, AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTilezero<AsmRegisterTmm> for CodeAssembler

Source§

impl CodeAsmTlbsync for CodeAssembler

Source§

fn tlbsync(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmTpause<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmTpause<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmTzcnt<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmTzcnt<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn tzcnt( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmTzcnt<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmTzcnt<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn tzcnt( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmTzcnt<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmTzcnt<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn tzcnt( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmTzmsk<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmTzmsk<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn tzmsk( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmTzmsk<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmTzmsk<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn tzmsk( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmUcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmUcomisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmUcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmUcomiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmUd0 for CodeAssembler

Source§

fn ud0(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmUd02<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmUd02<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn ud0_2( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmUd02<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmUd02<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn ud0_2( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmUd02<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmUd02<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn ud0_2( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmUd1<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn ud1( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmUd1<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn ud1( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmUd1<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn ud1( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmUd1<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn ud1( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmUd1<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn ud1( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmUd1<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn ud1( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmUd2 for CodeAssembler

Source§

fn ud2(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmUiret for CodeAssembler

Source§

fn uiret(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmUmonitor<AsmRegister16> for CodeAssembler

Source§

impl CodeAsmUmonitor<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmUmonitor<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn umov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn umov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmUmov<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn umov( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmUmov<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn umov( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmUmov<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn umov( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmUmov<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn umov( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmUmov<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn umov( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmUmov<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn umov( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmUmov<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn umov( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmUmwait<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmUmwait<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmUnpckhpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmUnpckhpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmUnpckhps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmUnpckhps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmUnpcklpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmUnpcklpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmUnpcklps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmUnpcklps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmV4fmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmV4fmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmV4fnmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmV4fnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVaddpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVaddph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaddph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVaddph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaddsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVaesdec<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesdec<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaesdec<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesdec<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVaesdec<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesdec<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVaesdeclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesdeclast<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaesdeclast<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesdeclast<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVaesdeclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesdeclast<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVaesenc<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesenc<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaesenc<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesenc<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVaesenc<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesenc<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVaesenclast<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesenclast<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaesenclast<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesenclast<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVaesenclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesenclast<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVaesimc<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVaesimc<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVaeskeygenassist<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVandnpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandnpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVandnpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandnpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVandnpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandnpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVandnps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandnps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVandnps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandnps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVandnps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandnps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVandpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVandpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVandpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVandps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVandps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVandps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVandps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVbcstnebf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbcstnebf162ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbcstnesh2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbcstnesh2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVblendmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVblendmpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVblendmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVblendmpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVblendmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVblendmpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVblendmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVblendmps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVblendmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVblendmps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVblendmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVblendmps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vblendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVblendpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vblendpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vblendpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVblendpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vblendpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vblendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVblendps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vblendps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vblendps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVblendps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vblendps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVblendvpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVblendvpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVblendvpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVblendvpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVblendvps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVblendvps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVblendvps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVblendvps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVbroadcastf128<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastf32x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastf32x2<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVbroadcastf32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastf32x2<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVbroadcastf32x4<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastf32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastf32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastf64x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastf64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastf64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti128<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti32x2<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti32x2<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVbroadcasti32x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti32x2<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVbroadcasti32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti32x2<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVbroadcasti32x4<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti64x2<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcasti64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastsd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastsd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVbroadcastsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastsd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVbroadcastss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVbroadcastss<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastss<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVbroadcastss<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVbroadcastss<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpeqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpeqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalse_osss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalseps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpfalsess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpfalsess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpge_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgeps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpgtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpgtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmple_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmple_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpleps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmplt_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpltss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_oqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ospd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ossd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_osss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneq_usss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpneqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpneqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnge_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngeps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpngtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpngtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnle_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnleps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnlt_uqss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpnltss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpnltss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_ssh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpordss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmppd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vcmppd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vcmpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmpsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcmpss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_uspd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_ussd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrue_usss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptrueps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptruesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmptruess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmptruess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_spd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_ssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_ssh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunord_sss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcmpunordss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcmpunordss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcomisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcomish<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcomiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcompresspd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcompresspd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcompresspd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcompressps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcompressps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcompressps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtdq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtdq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtdq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2pd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ph<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtdq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtdq2ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtne2ps2bf16<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtne2ps2bf16<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtne2ps2bf16<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtne2ps2bf16<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtne2ps2bf16<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtne2ps2bf16<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtneebf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneebf162ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneeph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneeph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneobf162ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneobf162ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneoph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneoph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtneps2bf16<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtneps2bf16<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneps2bf16<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtneps2bf16x<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtneps2bf16y<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2dq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2dq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2dqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2dqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2ps<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2ps<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2qq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2qq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2udq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2udq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2udqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2udqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2uqq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtpd2uqq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2dq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2dq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2pd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2ps<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2ps<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2psx<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2psx<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2psx<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2psx<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2psx<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2qq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2udq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2udq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2uqq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2uw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2uw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2uw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2uw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2w<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2w<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2w<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtph2w<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2dq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2dq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2pd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2ph<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vcvtps2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2phx<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2phx<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2phx<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2phxx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2phxy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2qq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2udq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2udq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtps2uqq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2pd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2ps<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2ps<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtqq2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtqq2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsd2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsd2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsd2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsd2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsd2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsd2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsh2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsh2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsh2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsh2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsh2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsh2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsh2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsh2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVcvtsi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVcvtsi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVcvtsi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVcvtss2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtss2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtss2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtss2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtss2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtss2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2dq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2dq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2dqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2dqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2qq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2qq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2udq<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2udq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2udqx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2udqy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2uqq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttpd2uqq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2dq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2dq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2qq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2udq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2udq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2uqq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2uw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2uw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2uw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2uw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2uw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2w<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2w<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2w<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2w<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttph2w<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2dq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2dq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2dq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2dq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2dq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2qq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2qq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2qq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2qq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2qq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2udq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2udq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2udq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2udq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2udq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2uqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2uqq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2uqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2uqq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttps2uqq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvttsd2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttsd2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttsd2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttsd2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttsd2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttsd2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttsd2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttsd2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttsh2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttsh2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttsh2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttsh2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttsh2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttsh2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttsh2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttsh2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttss2si<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttss2si<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttss2si<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttss2si<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttss2usi<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttss2usi<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvttss2usi<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvttss2usi<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtudq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtudq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2pd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtudq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2pd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ph<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtudq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtudq2ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2pd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2phx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2phy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2phz<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2ps<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2ps<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2psx<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuqq2psy<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVcvtusi2sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVcvtusi2sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVcvtusi2ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVcvtuw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuw2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtuw2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuw2ph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtuw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtuw2ph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVcvtw2ph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtw2ph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVcvtw2ph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtw2ph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVcvtw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVcvtw2ph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdbpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vdbpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vdbpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdbpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vdbpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdivpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVdivpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVdivpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVdivph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVdivph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVdivph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVdivps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVdivps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVdivps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVdivsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVdivsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVdivss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdivss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVdpbf16ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdpbf16ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVdpbf16ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdpbf16ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVdpbf16ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVdpbf16ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdppd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vdppd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdpps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vdpps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVdpps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vdpps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVerr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVerr<AsmRegister16> for CodeAssembler

Source§

fn verr(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmVerr<AsmRegister32> for CodeAssembler

Source§

fn verr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmVerr<AsmRegister64> for CodeAssembler

Source§

fn verr(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmVerw<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVerw<AsmRegister16> for CodeAssembler

Source§

fn verw(&mut self, op0: AsmRegister16) -> Result<(), IcedError>

Source§

impl CodeAsmVerw<AsmRegister32> for CodeAssembler

Source§

fn verw(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmVerw<AsmRegister64> for CodeAssembler

Source§

fn verw(&mut self, op0: AsmRegister64) -> Result<(), IcedError>

Source§

impl CodeAsmVexp2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVexp2pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVexp2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVexp2ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVexpandpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVexpandpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVexpandpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVexpandpd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVexpandpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVexpandpd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVexpandps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVexpandps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVexpandps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVexpandps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVexpandps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVexpandps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVextractf128<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVextractf128<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVextractf128<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vextractf128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf128<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vextractf128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vextractf32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVextractf32x8<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vextractf32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf32x8<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vextractf32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vextractf64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVextractf64x4<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vextractf64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractf64x4<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vextractf64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti128<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVextracti128<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVextracti128<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vextracti128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti128<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vextracti128( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vextracti32x4( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVextracti32x8<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vextracti32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti32x8<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vextracti32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vextracti64x2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVextracti64x4<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vextracti64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextracti64x4<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vextracti64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractps<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vextractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractps<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vextractps( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractps<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vextractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractps<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vextractps( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractps<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vextractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVextractps<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vextractps( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfcmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfcmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfcmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfcmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfcmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfcmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfcmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfcmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfcmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfcmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfcmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfcmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfcmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfcmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfcmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfcmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVfixupimmss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVfmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddcph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmaddsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmulcph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmulcph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfmulcsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmadd231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmaddsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmaddss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub132ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub213ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231sh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsub231ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfnmsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclasspdx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclasspdx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclasspdy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclasspdy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclasspdz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclasspdz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclassphx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclassphx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclassphy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclassphy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclassphz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclassphz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclasspsx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclasspsx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclasspsy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclasspsy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclasspsz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclasspsz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasssd<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasssd<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasssh<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclasssh<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassss<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfpclassss<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVfrczpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfrczpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfrczpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfrczpd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfrczps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfrczps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfrczps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfrczps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVfrczsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfrczsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVfrczss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVfrczss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgatherdpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherdpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherdpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherdpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgatherdpd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVgatherdps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherdps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherdps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherdps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgatherdps3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVgatherpf0dpd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherpf0dps<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherpf0qpd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherpf0qps<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherpf1dpd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherpf1dps<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherpf1qpd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherpf1qps<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherqpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherqpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherqpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherqpd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgatherqpd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVgatherqps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherqps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgatherqps3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgetexppd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexppd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgetexppd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexppd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVgetexppd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexppd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVgetexpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexpph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgetexpph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexpph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVgetexpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexpph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVgetexpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexpps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgetexpps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexpps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVgetexpps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexpps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVgetexpsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexpsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgetexpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexpsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgetexpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgetexpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vgetmantpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vgetmantph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vgetmantps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVgetmantsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVgetmantsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVgetmantss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVgf2p8mulb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgf2p8mulb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVgf2p8mulb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgf2p8mulb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVgf2p8mulb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVgf2p8mulb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVhaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVhaddpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVhaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVhaddpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVhaddps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVhaddps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVhaddps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVhaddps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVhsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVhsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVhsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVhsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVhsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVhsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVhsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVhsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinserti128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinserti32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinserti64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVinsertps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vinsertps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVlddqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVlddqu<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVldmxcsr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaskmovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmaskmovpd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmaskmovpd<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmaskmovpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaskmovpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaskmovps<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmaskmovps<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmaskmovps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaskmovps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmaxpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmaxpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmaxph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmaxph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmaxph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmaxps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmaxps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmaxps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmaxsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmaxss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmaxss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmcall for CodeAssembler

Source§

fn vmcall(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVmclear<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmfunc for CodeAssembler

Source§

fn vmfunc(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVmgexit for CodeAssembler

Source§

fn vmgexit(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVminpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVminpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVminpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVminph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVminph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVminph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVminps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVminps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVminps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVminsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVminss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVminss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmlaunch for CodeAssembler

Source§

fn vmlaunch(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVmload for CodeAssembler

Source§

fn vmload(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVmmcall for CodeAssembler

Source§

fn vmmcall(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovapd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovapd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovapd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovapd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovapd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovapd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovaps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovaps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovaps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovaps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovaps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovaps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

fn vmovd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmovd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

fn vmovd( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmovddup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovddup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovddup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovddup<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovddup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovddup<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqa<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqa<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqa32<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa32<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqa32<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqa32<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqa64<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa64<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqa64<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqa64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqa64<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu16<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu16<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu16<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu16<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu16<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu16<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu32<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu32<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu32<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu32<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu32<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu64<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu64<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu64<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu64<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu64<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu8<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu8<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu8<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu8<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovdqu8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovdqu8<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovhlps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovhpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovhpd3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovhps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovhps3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovlhps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovlpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovlpd3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovlps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovlps3<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovmskpd<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovmskpd<AsmRegister32, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovmskpd<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovmskpd<AsmRegister64, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovmskps<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovmskps<AsmRegister32, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovmskps<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovmskps<AsmRegister64, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovntdqa<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovntdqa<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovntdqa<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovq<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

fn vmovq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmovq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

fn vmovq( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmovq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn vmovq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmovsd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovsd3<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovsh<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovsh<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovsh3<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovshdup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovshdup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovshdup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovshdup<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovshdup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovshdup<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovsldup<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovsldup<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovsldup<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovsldup<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovsldup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovsldup<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovss<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovss3<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovupd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovupd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovupd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovupd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovupd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovupd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovups<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovups<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovups<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovups<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmovups<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovups<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmovw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmovw<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

fn vmovw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmovw<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

fn vmovw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmovw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmovw<AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

fn vmovw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmovw<AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

fn vmovw( &mut self, op0: AsmRegisterXmm, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vmpsadbw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vmpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vmpsadbw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmptrld<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmptrst<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVmread<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVmread<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn vmread( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmread<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn vmread( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmresume for CodeAssembler

Source§

fn vmresume(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVmrun for CodeAssembler

Source§

fn vmrun(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVmsave for CodeAssembler

Source§

fn vmsave(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVmulpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmulpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmulpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmulph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmulph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmulph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmulps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmulps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVmulps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVmulsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmulsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmulss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmulss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVmwrite<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmwrite<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn vmwrite( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmwrite<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVmwrite<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn vmwrite( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmVmxoff for CodeAssembler

Source§

fn vmxoff(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVmxon<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVorpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVorpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVorpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVorpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVorps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVorps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVorps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVorps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVp4dpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVp4dpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpabsb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsb<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpabsb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpabsd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpabsd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpabsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpabsq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpabsq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpabsq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpabsw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpabsw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpabsw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpabsw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpackssdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpackssdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpackssdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpackssdw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpackssdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpackssdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpacksswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpacksswb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpacksswb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpacksswb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpacksswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpacksswb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpackusdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpackusdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpackusdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpackusdw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpackusdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpackusdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpackuswb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpackuswb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpackuswb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpackuswb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpackuswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpackuswb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpaddb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpaddb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpaddb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpaddd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpaddd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpaddq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpaddq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpaddq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpaddsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpaddsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddsb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpaddsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpaddsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpaddusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddusb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpaddusb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddusb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpaddusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddusb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpaddusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddusw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpaddusw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddusw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpaddusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddusw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpaddw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpaddw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpaddw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpalignr<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpalignr( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpalignr( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpalignr<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpalignr( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpand<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpand<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpand<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpand<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpandd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpandd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpandd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpandn<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandn<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpandn<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandn<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpandnd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandnd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpandnd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandnd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpandnd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandnd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpandnq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandnq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpandnq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandnq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpandnq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandnq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpandq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpandq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpandq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpandq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpavgb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpavgb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpavgb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpavgb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpavgb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpavgb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpavgw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpavgw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpavgw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpavgw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpavgw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpavgw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpblendd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpblendd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpblendd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpblendd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpblendd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpblendmb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpblendmb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpblendmb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpblendmd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpblendmd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpblendmd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpblendmq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpblendmq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpblendmq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpblendmw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpblendmw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpblendmw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpblendmw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpblendvb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpblendvb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpblendvb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpblendvb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpblendw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpblendw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpblendw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpblendw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpblendw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVpbroadcastb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVpbroadcastb<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVpbroadcastd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVpbroadcastd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastmb2q<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpbroadcastmb2q<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpbroadcastmb2q<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpbroadcastmw2d<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpbroadcastmw2d<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpbroadcastmw2d<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVpbroadcastq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVpbroadcastq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVpbroadcastw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVpbroadcastw<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmulhqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpclmulhqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmulhqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpclmulhqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmulhqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmulhqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpclmulhqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmulhqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpclmulhqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmulhqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmullqhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpclmullqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmullqhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpclmullqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmullqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmullqlqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpclmullqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmullqlqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpclmullqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpclmullqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmov<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmov<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmov<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmov<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpeqw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpestri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestri64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpestri64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpestrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpestrm64<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpestrm64( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpgtw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpistri<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpistri( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpistrm<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpistrm( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcomb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcomd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomeqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomeqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomeqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomeqd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomeqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomeqq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomequb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomequd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomequq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomequw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomeqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomeqw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomfalseb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomfalseb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomfalsed<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomfalsed<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomfalseq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomfalseq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomfalseub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomfalseub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomfalseud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomfalseud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomfalseuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomfalseuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomfalseuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomfalseuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomfalsew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomfalsew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgeb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgeb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomged<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomged<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgeq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgeq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgeub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgeub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgeud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgeud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgeuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgeuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgeuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgeuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgtb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgtb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgtd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgtd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgtq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgtq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgtub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgtub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgtud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgtud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgtuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgtuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgtuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgtuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomgtw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomgtw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomleb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomleb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomled<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomled<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomleq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomleq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomleub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomleub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomleud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomleud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomleuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomleuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomleuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomleuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomlew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomlew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomltb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomltb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomltd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomltd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomltq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomltq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomltub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomltub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomltud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomltud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomltuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomltuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomltuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomltuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomltw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomltw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomneqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomneqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomneqd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomneqd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomneqq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomneqq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomnequb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomnequb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomnequd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomnequd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomnequq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomnequq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomnequw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomnequw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomneqw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomneqw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcompressb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcompressb<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcompressb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcompressd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcompressd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcompressd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcompressq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcompressq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcompressq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcompressw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcompressw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpcompressw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcomq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomtrueb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomtrueb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomtrued<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomtrued<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomtrueq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomtrueq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomtrueub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomtrueub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomtrueud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomtrueud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomtrueuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomtrueuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomtrueuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomtrueuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomtruew<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpcomtruew<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcomub( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcomud( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcomuq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcomuw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpcomw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpcomw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpconflictd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpconflictd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpconflictd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpconflictd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpconflictd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpconflictd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpconflictq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpconflictq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpconflictq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpconflictq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpconflictq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpconflictq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpdpbssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpbssd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbssd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpbssds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbssds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpbssds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbssds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpbsud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbsud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpbsud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbsud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpbsuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbsuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpbsuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbsuds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpbusd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbusd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpbusd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbusd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpbusd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbusd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpdpbusds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbusds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpbusds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbusds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpbusds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbusds<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpdpbuud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbuud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpbuud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbuud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpbuuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbuuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpbuuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpbuuds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpwssd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwssd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpwssd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwssd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpdpwssds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwssds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpwssds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwssds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpdpwsud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwsud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpwsud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwsud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpwsuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwsuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpwsuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwsuds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpwusd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwusd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpwusd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwusd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpwusds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwusds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpwusds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwusds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpwuud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwuud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpwuud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwuud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpdpwuuds<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwuuds<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpdpwuuds<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpdpwuuds<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVperm2f128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVperm2i128<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVpermb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermi2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2b<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermi2b<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2b<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermi2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2b<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermi2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2d<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermi2d<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2d<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermi2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2d<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermi2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermi2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermi2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermi2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermi2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermi2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermi2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2q<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermi2q<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2q<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermi2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2q<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermi2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2w<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermi2w<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2w<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermi2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermi2w<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVpermil2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpermilpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpermilps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermpd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpermpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpermpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpermq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpermq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpermt2b<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2b<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermt2b<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2b<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermt2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2b<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermt2d<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2d<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermt2d<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2d<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermt2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2d<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermt2pd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2pd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermt2pd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2pd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermt2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermt2ps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2ps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermt2ps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2ps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermt2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermt2q<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2q<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermt2q<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2q<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermt2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2q<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermt2w<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2w<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermt2w<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2w<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermt2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermt2w<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpermw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpermw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpermw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpermw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpexpandb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpexpandb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandb<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpexpandb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpexpandd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpexpandd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpexpandd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpexpandq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpexpandq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpexpandq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpexpandw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpexpandw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpexpandw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpexpandw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpextrb<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrb<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrb( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrb<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrb<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrb( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrb<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrb<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrb( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrd<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrd<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrd( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrd<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrd<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrd( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrq<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrq<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrq( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrq<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrq<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrq( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrw<AsmMemoryOperand, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrw<AsmMemoryOperand, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrw( &mut self, op0: AsmMemoryOperand, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrw<AsmRegister32, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrw<AsmRegister32, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrw( &mut self, op0: AsmRegister32, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrw<AsmRegister64, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpextrw<AsmRegister64, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpextrw( &mut self, op0: AsmRegister64, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpgatherdd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherdd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherdd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherdd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpgatherdd3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpgatherdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherdq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpgatherdq3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpgatherqd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherqd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherqd3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpgatherqq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherqq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpgatherqq3<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpgatherqq3<AsmRegisterYmm, AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVphaddbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVphadddq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphadddq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVphaddubd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddubd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddubq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddubq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddubw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddubw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddudq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddudq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphadduwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphadduwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphadduwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphadduwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVphaddwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphaddwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphaddwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphminposuw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphminposuw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphsubbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphsubbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphsubd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphsubd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphsubd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVphsubdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphsubdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVphsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphsubw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVphsubw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphsubw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVphsubwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVphsubwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

Source§

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

Source§

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

Source§

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrb<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

Source§

fn vpinsrb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

Source§

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrd<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

Source§

fn vpinsrd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

Source§

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrq<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

Source§

fn vpinsrq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, i32> for CodeAssembler

Source§

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister32, u32> for CodeAssembler

Source§

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister32, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, i32> for CodeAssembler

Source§

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpinsrw<AsmRegisterXmm, AsmRegisterXmm, AsmRegister64, u32> for CodeAssembler

Source§

fn vpinsrw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegister64, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVplzcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVplzcntd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVplzcntd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVplzcntd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVplzcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVplzcntd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVplzcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVplzcntq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVplzcntq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVplzcntq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVplzcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVplzcntq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmacsdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacsdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacsdqh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacsdqh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacsdql<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacsdql<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacssdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacssdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacssdqh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacssdqh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacssdql<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacssdql<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacsswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacsswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacssww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacssww<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacsww<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmacsww<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmadcsswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmadcsswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmadcswd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmadcswd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmadd52huq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmadd52huq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmadd52huq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmadd52huq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmadd52huq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmadd52huq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmadd52luq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmadd52luq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmadd52luq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmadd52luq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmadd52luq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmadd52luq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaddubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaddubsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaddubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaddubsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaddubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaddubsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaddwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaddwd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaddwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaddwd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaddwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaddwd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaskmovd<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaskmovd<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaskmovd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaskmovd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaskmovq<AsmMemoryOperand, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaskmovq<AsmMemoryOperand, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaskmovq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaskmovq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaxsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaxub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaxub<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxub<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaxub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxub<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaxud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaxud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaxud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxud<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaxuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaxuq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxuq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaxuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxuq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmaxuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmaxuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxuw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmaxuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmaxuw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpminsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpminsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpminsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpminsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpminsd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpminsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpminsq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpminsq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpminsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpminsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpminsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpminsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpminub<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminub<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpminub<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminub<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpminub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminub<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpminud<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminud<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpminud<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminud<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpminud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminud<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpminuq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminuq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpminuq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminuq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpminuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminuq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpminuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpminuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminuw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpminuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpminuw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovdw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovdw<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovm2b<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2b<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2b<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2d<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2d<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2d<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2q<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2q<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2q<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2w<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2w<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovm2w<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

Source§

impl CodeAsmVpmovmskb<AsmRegister32, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovmskb<AsmRegister32, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovmskb<AsmRegister64, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovmskb<AsmRegister64, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovqd<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovqd<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsdw<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqd<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqd<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovswb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovswb<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxbd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxbd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxbd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxbq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxbq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxbq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxbw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxbw<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxbw<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxdq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxdq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxwd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxwd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxwd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxwq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxwq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovsxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovsxwq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusdw<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqd<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqd<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovuswb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovuswb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovuswb<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovwb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovwb<AsmRegisterXmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovwb<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxbd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxbd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxbd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxbd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxbd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxbq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxbq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxbq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxbq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxbq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxbw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxbw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxbw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxbw<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxbw<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxdq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxdq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxdq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxdq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxdq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxwd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxwd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxwd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxwd<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxwd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxwq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxwq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxwq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxwq<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmovzxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmovzxwq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmuldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmuldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmuldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmuldq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmuldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmuldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmulhrsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulhrsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmulhrsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulhrsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmulhrsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulhrsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmulhuw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulhuw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmulhuw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulhuw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmulhuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulhuw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmulhw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulhw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmulhw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulhw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmulhw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulhw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmulld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmulld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulld<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmulld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmulld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmullq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmullq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmullq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmullq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmullq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmullq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmullw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmullw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmullw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmullw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmullw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmullw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmultishiftqb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmultishiftqb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmultishiftqb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmultishiftqb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmultishiftqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmultishiftqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpmuludq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmuludq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpmuludq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmuludq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpmuludq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpmuludq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpopcntb<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntb<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpopcntb<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntb<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpopcntb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpopcntd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpopcntd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpopcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpopcntq<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntq<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpopcntq<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntq<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpopcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpopcntw<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntw<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpopcntw<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntw<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpopcntw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpopcntw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpor<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpor<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpor<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpord<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpord<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpord<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpord<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVporq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVporq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVporq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVporq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVporq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVporq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpperm<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprold<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprold<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vprold( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vprolq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprolvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprolvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprolvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprolvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVprolvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprolvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVprolvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprolvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprolvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprolvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVprolvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprolvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVprord<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprord<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vprord( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vprorq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprorvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprorvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprorvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprorvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVprorvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprorvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVprorvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprorvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprorvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprorvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVprorvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprorvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotb<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotb<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vprotb( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vprotd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vprotq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVprotw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vprotw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsadbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsadbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpscatterqd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpscatterqd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpshab<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshab<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshab<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshad<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshad<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshad<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshaq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshaq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshaq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshaw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshaw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshaw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshlb<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshlb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshlb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshld<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshldvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshldvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshldvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpshldvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshldvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpshldvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshldvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshldvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshldvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpshldvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshldvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpshldvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshldvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshldvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshldvw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpshldvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshldvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshlq<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshlq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshlq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshlw<AsmRegisterXmm, AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshlw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshlw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshrdvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshrdvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshrdvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpshrdvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshrdvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpshrdvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshrdvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshrdvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshrdvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpshrdvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshrdvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpshrdvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshrdvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshrdvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshrdvw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpshrdvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshrdvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshufb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshufb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshufb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpshufb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshufb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpshufd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpshufd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpshufhw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpshuflw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsignb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsignb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsignb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsignb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsignd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsignd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsignd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsignd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsignw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsignw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsignw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsignw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpslld<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpslld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpslldq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpslldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpsllq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsllvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsllvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsllvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsllvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsllvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsllvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsllvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllvw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsllvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsllw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpsllw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpsrad( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpsraq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsravd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsravd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsravd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsravd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsravd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsravd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsravq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsravq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsravq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsravq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsravq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsravq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsravw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsravw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsravw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsravw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsravw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsravw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsraw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpsraw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpsrld( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpsrldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpsrlq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlvd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlvd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrlvd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlvd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsrlvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsrlvq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlvq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrlvq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlvq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsrlvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsrlvw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlvw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrlvw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlvw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsrlvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vpsrlw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVpsubb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsubb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsubb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsubd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsubd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsubd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsubq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsubq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsubq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsubsb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubsb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsubsb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubsb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsubsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubsw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubsw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsubusb<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubusb<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsubusb<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubusb<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsubusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubusb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsubusw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubusw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsubusw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubusw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsubusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubusw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpsubw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpsubw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpsubw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpsubw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVptest<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptest<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVptest<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptest<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhwd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhwd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpunpckhwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckhwd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpunpcklbw<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpcklbw<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpunpcklbw<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpcklbw<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpunpcklbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpcklbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpunpckldq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckldq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpunpckldq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckldq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpunpckldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpckldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpunpcklqdq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpcklqdq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpunpcklqdq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpcklqdq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpunpcklqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpcklqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpunpcklwd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpcklwd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpunpcklwd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpcklwd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpunpcklwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpunpcklwd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpxor<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpxor<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpxor<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpxor<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpxord<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpxord<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpxord<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpxord<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpxord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpxord<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVpxorq<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpxorq<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVpxorq<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpxorq<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVpxorq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVpxorq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangepd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vrangepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vrangepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangepd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vrangepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangeps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vrangeps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vrangeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangeps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vrangeps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vrangesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrangess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vrangess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrcp14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp14pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrcp14pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp14pd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVrcp14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp14pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrcp14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp14ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrcp14ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp14ps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVrcp14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp14ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrcp14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp14sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrcp14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp14ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrcp28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp28pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrcp28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp28ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrcp28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp28sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrcp28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcp28ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrcpph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcpph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrcpph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcpph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVrcpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcpph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrcpps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcpps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrcpps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcpps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVrcpsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcpsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrcpss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrcpss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVreducepd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducepd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vreducepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceph<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vreduceph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreduceps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vreduceps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vreducesd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vreducesh( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVreducess<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vreducess( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vrndscalepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vrndscaleph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vrndscaleps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVrndscalesd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVrndscalesh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

impl CodeAsmVrndscaless<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

impl CodeAsmVroundpd<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundpd<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundpd<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundpd<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vroundpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundpd<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundpd<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundpd<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundpd<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vroundpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundps<AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundps<AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundps<AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundps<AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vroundps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundps<AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundps<AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmMemoryOperand, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundps<AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundps<AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vroundps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vroundsd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVroundss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vroundss( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVrsqrt14pd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt14pd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt14pd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt14pd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt14pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt14ps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt14ps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt14ps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt14ps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt14ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt14sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt14sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt14ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt14ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt28pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt28ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt28sd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt28sd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrsqrt28ss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrt28ss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrtph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrsqrtph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrtph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVrsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrtph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVrsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrsqrtps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrtps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVrsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVrsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVrsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscalefpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscalefpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVscalefpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVscalefph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscalefph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVscalefph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVscalefps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscalefps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVscalefps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVscalefsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscalefsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscalefss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscalefss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVscatterpf0dpd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscatterpf0dps<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscatterpf0qpd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscatterpf0qps<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscatterpf1dpd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscatterpf1dps<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscatterpf1qpd<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscatterpf1qps<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVscatterqps<AsmMemoryOperand, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVscatterqps<AsmMemoryOperand, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsha512msg1<AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsha512msg2<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsha512rnds2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVshuff32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVshuff64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVshufi32x4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

impl CodeAsmVshufi64x2<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

Source§

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVsm3msg1<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsm3msg1<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsm3msg2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsm3msg2<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

Source§

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

Source§

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

Source§

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVsm3rnds2<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

Source§

fn vsm3rnds2( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32, ) -> Result<(), IcedError>

Source§

impl CodeAsmVsm4key4<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsm4key4<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsm4key4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsm4key4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsm4rnds4<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsm4rnds4<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsm4rnds4<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsm4rnds4<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsqrtpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsqrtpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtpd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsqrtpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtpd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVsqrtph<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtph<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsqrtph<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtph<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVsqrtps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsqrtps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsqrtps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVsqrtsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsqrtss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVstmxcsr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsubpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVsubph<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubph<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsubph<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubph<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsubph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVsubps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsubps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVsubps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubsd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsubsh<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubsh<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVsubss<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVsubss<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVtestpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVtestpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVtestpd<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVtestpd<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVtestps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVtestps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVtestps<AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVtestps<AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVucomisd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVucomisd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVucomish<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVucomish<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVucomiss<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVucomiss<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVunpckhpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpckhpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVunpckhpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpckhpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVunpckhpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpckhpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVunpckhps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpckhps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVunpckhps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpckhps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVunpckhps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpckhps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVunpcklpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpcklpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVunpcklpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpcklpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVunpcklpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpcklpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVunpcklps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpcklps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVunpcklps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpcklps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVunpcklps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVunpcklps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVxorpd<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVxorpd<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVxorpd<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVxorpd<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVxorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVxorpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVxorps<AsmRegisterXmm, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVxorps<AsmRegisterXmm, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

impl CodeAsmVxorps<AsmRegisterYmm, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVxorps<AsmRegisterYmm, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

Source§

impl CodeAsmVxorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmVxorps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

Source§

impl CodeAsmVzeroall for CodeAssembler

Source§

fn vzeroall(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmVzeroupper for CodeAssembler

Source§

impl CodeAsmWait for CodeAssembler

Source§

fn wait(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmWbinvd for CodeAssembler

Source§

fn wbinvd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmWbnoinvd for CodeAssembler

Source§

fn wbnoinvd(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmWrfsbase<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmWrfsbase<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmWrgsbase<AsmRegister32> for CodeAssembler

Source§

impl CodeAsmWrgsbase<AsmRegister64> for CodeAssembler

Source§

impl CodeAsmWrmsr for CodeAssembler

Source§

fn wrmsr(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmWrmsrlist for CodeAssembler

Source§

impl CodeAsmWrmsrns for CodeAssembler

Source§

fn wrmsrns(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmWrpkru for CodeAssembler

Source§

fn wrpkru(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmWrshr<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmWrshr<AsmRegister32> for CodeAssembler

Source§

fn wrshr(&mut self, op0: AsmRegister32) -> Result<(), IcedError>

Source§

impl CodeAsmWrssd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmWrssq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmWrudbg for CodeAssembler

Source§

fn wrudbg(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmWrussd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

impl CodeAsmWrussq<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

impl CodeAsmXabort<i32> for CodeAssembler

Source§

fn xabort(&mut self, op0: i32) -> Result<(), IcedError>

Source§

impl CodeAsmXabort<u32> for CodeAssembler

Source§

fn xabort(&mut self, op0: u32) -> Result<(), IcedError>

Source§

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmXadd<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn xadd( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmXadd<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn xadd( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmXadd<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn xadd( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmXadd<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn xadd( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmXadd<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn xadd( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmXbegin<CodeLabel> for CodeAssembler

Source§

fn xbegin(&mut self, op0: CodeLabel) -> Result<(), IcedError>

Source§

impl CodeAsmXbegin<u64> for CodeAssembler

Source§

fn xbegin(&mut self, op0: u64) -> Result<(), IcedError>

Source§

impl CodeAsmXbts<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn xbts( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmXbts<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn xbts( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmXbts<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn xbts( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmXbts<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn xbts( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmXchg<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn xchg( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmXchg<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn xchg( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmXchg<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn xchg( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmXchg<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn xchg( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmXchg<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn xchg( &mut self, op0: AsmRegister8, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmXcryptcbc for CodeAssembler

Source§

impl CodeAsmXcryptcfb for CodeAssembler

Source§

impl CodeAsmXcryptctr for CodeAssembler

Source§

impl CodeAsmXcryptecb for CodeAssembler

Source§

impl CodeAsmXcryptofb for CodeAssembler

Source§

impl CodeAsmXend for CodeAssembler

Source§

fn xend(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmXgetbv for CodeAssembler

Source§

fn xgetbv(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmMemoryOperand, AsmRegister16> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmMemoryOperand, AsmRegister32> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmMemoryOperand, AsmRegister64> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmMemoryOperand, AsmRegister8> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmMemoryOperand, op1: AsmRegister8, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmMemoryOperand, i32> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmMemoryOperand, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmMemoryOperand, u32> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmMemoryOperand, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister16, AsmMemoryOperand> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmRegister16, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister16, AsmRegister16> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmRegister16, op1: AsmRegister16, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister16, i32> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmRegister16, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister16, u32> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmRegister16, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister32, AsmMemoryOperand> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmRegister32, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister32, AsmRegister32> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmRegister32, op1: AsmRegister32, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister32, i32> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmRegister32, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister32, u32> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmRegister32, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister64, AsmMemoryOperand> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmRegister64, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister64, AsmRegister64> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmRegister64, op1: AsmRegister64, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister64, i32> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmRegister64, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister8, AsmMemoryOperand> for CodeAssembler

Source§

fn xor( &mut self, op0: AsmRegister8, op1: AsmMemoryOperand, ) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister8, AsmRegister8> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmRegister8, op1: AsmRegister8) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister8, i32> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmRegister8, op1: i32) -> Result<(), IcedError>

Source§

impl CodeAsmXor<AsmRegister8, u32> for CodeAssembler

Source§

fn xor(&mut self, op0: AsmRegister8, op1: u32) -> Result<(), IcedError>

Source§

impl CodeAsmXorpd<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXorpd<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn xorpd( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmXorps<AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXorps<AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

Source§

fn xorps( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterXmm, ) -> Result<(), IcedError>

Source§

impl CodeAsmXresldtrk for CodeAssembler

Source§

impl CodeAsmXrstor<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXrstor64<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXrstors<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXrstors64<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXsave<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXsave64<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXsavec<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXsavec64<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXsaveopt<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXsaveopt64<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXsaves<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXsaves64<AsmMemoryOperand> for CodeAssembler

Source§

impl CodeAsmXsetbv for CodeAssembler

Source§

fn xsetbv(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmXsha1 for CodeAssembler

Source§

fn xsha1(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmXsha256 for CodeAssembler

Source§

fn xsha256(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmXsha512 for CodeAssembler

Source§

fn xsha512(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmXsha512_alt for CodeAssembler

Source§

impl CodeAsmXstore for CodeAssembler

Source§

fn xstore(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmXstore_alt for CodeAssembler

Source§

impl CodeAsmXsusldtrk for CodeAssembler

Source§

impl CodeAsmXtest for CodeAssembler

Source§

fn xtest(&mut self) -> Result<(), IcedError>

Source§

impl CodeAsmZero_bytes for CodeAssembler

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.