Struct iced_x86::code_asm::AsmRegisterZmm

pub struct AsmRegisterZmm { /* private fields */ }

Expand description

All 512-bit vector registers (ZMM).

This type is not part of the public API! It’s an implementation detail. The register identifiers, however, are part of the public API.

To use the registers, you must import everything from the module:

use iced_x86::code_asm::*;

or import them from this module:

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

or import only these registers:

use iced_x86::code_asm::registers::zmm::*;

Implementations§

impl AsmRegisterZmm

pub fn k1(self) -> Self

Adds a {k1} opmask register

pub fn k2(self) -> Self

Adds a {k2} opmask register

pub fn k3(self) -> Self

Adds a {k3} opmask register

pub fn k4(self) -> Self

Adds a {k4} opmask register

pub fn k5(self) -> Self

Adds a {k5} opmask register

pub fn k6(self) -> Self

Adds a {k6} opmask register

pub fn k7(self) -> Self

Adds a {k7} opmask register

pub fn z(self) -> Self

Enables zeroing masking {z}

pub fn sae(self) -> Self

Enables suppress all exceptions {sae}

pub fn rn_sae(self) -> Self

Round to nearest (even)

pub fn rd_sae(self) -> Self

Round down (toward -inf)

pub fn ru_sae(self) -> Self

Round up (toward +inf)

pub fn rz_sae(self) -> Self

Round toward zero (truncate)

Trait Implementations§

impl Add<AsmRegister32> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmRegister32) -> Self::Output

Performs the + operation. Read more

impl Add<AsmRegister64> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmRegister64) -> Self::Output

Performs the + operation. Read more

impl Add<AsmRegisterZmm> for AsmRegister32

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the + operation. Read more

impl Add<AsmRegisterZmm> for AsmRegister64

type Output = AsmMemoryOperand

The resulting type after applying the + operator.

fn add(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the + operation. Read more

impl Clone for AsmRegisterZmm

fn clone(&self) -> AsmRegisterZmm

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl CodeAsmV4fmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmV4fnmaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVaddph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVaddps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaddps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVaesdec<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaesdec<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVaesdeclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaesdeclast<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVaesenc<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaesenc<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVaesenclast<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVaesenclast<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmValignd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn valignd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmValignq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn valignq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVandnpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVandnpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVandnps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVandnps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVandpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVandpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVandps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVandps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVblendmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVblendmpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVblendmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVblendmps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVbroadcastf32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcastf32x2<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVbroadcastf32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcastf32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcastf64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcastf64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcasti32x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcasti32x2<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVbroadcasti32x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcasti32x8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcasti64x2<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcasti64x4<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcastsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcastsd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVbroadcastss<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVbroadcastss<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpeqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalse_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalse_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalse_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalsepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalseph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpfalseps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpge_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpge_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpge_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpgtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmple_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmple_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmple_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmplepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmplt_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmplt_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmplt_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_oqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_oqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_oqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_ospd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_osph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_osps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneq_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpneqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnge_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnge_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnge_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngeph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngeps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngtpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngtph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpngtps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnle_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnle_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnle_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnlepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnleph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnleps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnlt_uqpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnlt_uqph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnlt_uqps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnltpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnltph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpnltps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmppd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vcmppd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vcmpph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcompresspd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcompresspd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcompresspd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcompressps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcompressps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcompressps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtdq2pd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtdq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ph<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtdq2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtdq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtdq2ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtdq2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtne2ps2bf16<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtne2ps2bf16<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcvtneps2bf16<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtneps2bf16( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2dq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcvtpd2ps<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtpd2qq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2udq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtpd2uqq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtpd2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtph2dq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2dq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtph2pd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtph2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtph2ps<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2psx<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtph2psx<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2psx( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtph2qq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtph2udq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtph2udq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtph2uqq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvtph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtph2uw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtph2uw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtph2w<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtph2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtps2dq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtps2dq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtps2pd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVcvtps2ph<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVcvtps2ph<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVcvtps2ph<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vcvtps2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVcvtps2phx<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtps2phx( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtps2qq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtps2udq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtps2udq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtps2uqq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtps2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtqq2pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtqq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtqq2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcvtqq2ps<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtqq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2dq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvttpd2dq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttpd2qq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttpd2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2udq<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvttpd2udq( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvttpd2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttpd2uqq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttpd2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttph2dq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvttph2dq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttph2qq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttph2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttph2udq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvttph2udq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttph2uqq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcvttph2uw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttph2uw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttph2uw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvttph2w<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttph2w<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttph2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2dq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttps2dq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttps2dq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2qq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttps2qq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvttps2qq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2udq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttps2udq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvttps2udq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvttps2uqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvttps2uqq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvttps2uqq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtudq2pd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vcvtudq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ph<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtudq2ph( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtudq2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtudq2ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtudq2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtuqq2pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtuqq2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuqq2ph<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcvtuqq2ps<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vcvtuqq2ps( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtuw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtuw2ph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtuw2ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcvtw2ph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcvtw2ph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcvtw2ph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVdbpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vdbpsadbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVdivpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVdivpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVdivph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVdivph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVdivps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVdivps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVdpbf16ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVdpbf16ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVexp2pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVexp2pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vexp2pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVexp2ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVexp2ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vexp2ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVexpandpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVexpandpd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vexpandpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVexpandps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVexpandps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vexpandps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextractf32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextractf32x4<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextractf32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextractf32x8<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractf32x8<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextractf64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextractf64x2<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextractf64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextractf64x4<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextractf64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextractf64x4<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextractf64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextracti32x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextracti32x4<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextracti32x8<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextracti32x8<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextracti32x8<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti32x8( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextracti64x2<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextracti64x2<AsmRegisterXmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVextracti64x4<AsmMemoryOperand, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVextracti64x4<AsmRegisterYmm, AsmRegisterZmm, i32> for CodeAssembler

fn vextracti64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVextracti64x4<AsmRegisterYmm, AsmRegisterZmm, u32> for CodeAssembler

fn vextracti64x4( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfcmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfcmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfcmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfcmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vfixupimmpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVfixupimmps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vfixupimmps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVfmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmaddsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmaddsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsubadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsubadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsubadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsubadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsubadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsubadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsubadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsubadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsubadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsubadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsubadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsubadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsubadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsubadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsubadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsubadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmsubadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmsubadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfmulcph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmadd132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmadd132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmadd132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmadd213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmadd213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmadd213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmadd231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmadd231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmadd231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmsub132pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmsub132ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmsub132ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmsub213pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmsub213ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmsub213ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmsub231pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmsub231ph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfnmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVfnmsub231ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVgatherdpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVgatherdps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVgatherqpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVgetexppd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVgetexppd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vgetexppd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVgetexpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVgetexpph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vgetexpph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVgetexpps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVgetexpps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vgetexpps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVgetmantpd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVgetmantph<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVgetmantps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineinvqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vgf2p8affineinvqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8affineqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vgf2p8affineqb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVgf2p8mulb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVgf2p8mulb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVinsertf32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

fn vinsertf32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVinsertf64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinsertf64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

fn vinsertf64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVinserti32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti32x8<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

fn vinserti32x8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, i32> for CodeAssembler

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

impl CodeAsmVinserti64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm, u32> for CodeAssembler

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

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, i32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVinserti64x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterYmm, u32> for CodeAssembler

fn vinserti64x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVmaxpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmaxpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmaxph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmaxph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmaxps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmaxps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVminpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVminpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVminph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVminph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVminps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVminps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovapd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovapd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovapd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovapd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovaps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovaps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovaps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovaps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovddup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovddup<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovddup( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqa32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovdqa32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovdqa32<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqa32( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqa64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovdqa64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovdqa64<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqa64( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu16<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovdqu16<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovdqu16<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqu16( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu32<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovdqu32<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovdqu32<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqu32( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu64<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovdqu64<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovdqu64<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqu64( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovdqu8<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovdqu8<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovdqu8<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovdqu8( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovntdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovntdqa<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovntpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovntps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovshdup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovshdup<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovshdup( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovsldup<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovsldup<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovsldup( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovupd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovupd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovupd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovupd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmovups<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmovups<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmovups<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vmovups( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVmulpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmulpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmulph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmulph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVmulps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVmulps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVorpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVorps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVp4dpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVp4dpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpabsb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpabsb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpabsb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpabsd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpabsd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpabsd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpabsq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpabsq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpabsq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpabsw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpabsw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpabsw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpackssdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpackssdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpacksswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpacksswb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpackusdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpackusdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpackuswb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpackuswb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpaddb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpaddb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpaddd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpaddd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpaddq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpaddq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpaddsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpaddsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpaddsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpaddsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpaddusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpaddusb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpaddusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpaddusw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpaddw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpaddw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpalignr<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpalignr( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpandd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpandd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpandnd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpandnd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpandnq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpandnq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpandq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpandq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpavgb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpavgb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpavgw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpavgw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpblendmb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpblendmb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpblendmd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpblendmd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpblendmq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpblendmq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpblendmw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpblendmw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastb<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpbroadcastmb2q<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmb2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmw2d<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmw2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmRegister64> for CodeAssembler

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

impl CodeAsmVpbroadcastq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmRegister32> for CodeAssembler

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

impl CodeAsmVpbroadcastw<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpclmulhqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpclmulhqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpclmulhqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpclmulhqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpclmullqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpclmullqhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpclmullqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpclmullqlqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpclmulqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpclmulqdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcompressb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpcompressb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcompressb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpcompressd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcompressd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpcompressq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcompressq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcompressw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpcompressw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcompressw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpconflictd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpconflictd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpconflictd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpconflictq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpconflictq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpconflictq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpdpbusd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpdpbusd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpdpbusds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpdpbusds<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpdpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpdpwssd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpdpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpdpwssds<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermi2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermi2b<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermi2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermi2d<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermi2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermi2pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermi2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermi2ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermi2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermi2q<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermi2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermi2w<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpermilpd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpermilps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpermilps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpermpd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpermpd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpermps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpermq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpermq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpermt2b<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermt2b<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermt2d<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermt2d<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermt2pd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermt2pd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermt2ps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermt2ps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermt2q<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermt2q<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermt2w<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermt2w<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpermw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpermw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpexpandb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpexpandb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpexpandb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpexpandd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpexpandd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpexpandd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpexpandq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpexpandq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpexpandq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpexpandw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpexpandw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpexpandw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpgatherdd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpgatherdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpgatherqq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVplzcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVplzcntd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vplzcntd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVplzcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVplzcntq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vplzcntq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmadd52huq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmadd52huq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmadd52luq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmadd52luq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaddubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaddubsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaddwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaddwd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaxsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaxsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaxsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaxsd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaxsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaxsq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaxsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaxsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaxub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaxub<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaxud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaxud<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaxuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaxuq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmaxuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmaxuw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpminsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpminsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpminsd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpminsd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpminsq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpminsq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpminsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpminsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpminub<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpminub<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpminud<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpminud<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpminuq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpminuq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpminuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpminuw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovb2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovd2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovdw<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovm2b<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2b( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2d<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2q<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2w<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovq2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovqd<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovqd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovsdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovsdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovsdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovsdw<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovsqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovsqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovsqd<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovsqd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovsqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovswb<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovsxbd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpmovsxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovsxbq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpmovsxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovsxbw<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsxbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovsxdq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsxdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovsxwd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovsxwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovsxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovsxwq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpmovusdb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovusdb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovusdw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovusdw<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusdw( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovusqb<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovusqd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovusqd<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovusqd( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovusqw<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovusqw<AsmRegisterXmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovuswb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovuswb<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovuswb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovw2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovwb<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmovwb<AsmRegisterYmm, AsmRegisterZmm> for CodeAssembler

fn vpmovwb( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxbd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovzxbd<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpmovzxbq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovzxbq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpmovzxbw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovzxbw<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovzxbw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxdq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovzxdq<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovzxdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovzxwd<AsmRegisterZmm, AsmRegisterYmm> for CodeAssembler

fn vpmovzxwd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovzxwq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmovzxwq<AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpmuldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmuldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmulhrsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmulhrsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmulhuw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmulhuw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmulhw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmulhw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmulld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmulld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmullq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmullq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmullw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmullw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmultishiftqb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmultishiftqb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpmuludq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpmuludq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpopcntb<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpopcntb<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpopcntb( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpopcntd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpopcntd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpopcntd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpopcntq<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpopcntq<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpopcntq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpopcntw<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpopcntw<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpopcntw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpord<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVporq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVporq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVprold<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVprold<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVprold<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVprolq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVprolq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVprolq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVprolvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVprolvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVprolvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVprolvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVprord<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVprord<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVprord<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVprorq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVprorq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVprorq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVprorvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVprorvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVprorvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVprorvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsadbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpscatterdd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpscatterdq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpscatterqq<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshldd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshldq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpshldvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpshldvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpshldvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpshldvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpshldvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshldw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshldw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshrdd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshrdq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpshrdvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpshrdvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpshrdvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpshrdvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpshrdvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpshrdw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpshrdw( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpshufb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpshufb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpshufd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpshufd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpshufd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpshufhw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpshuflw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpslld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpslld<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpslldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpslldq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpslldq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpsllq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpsllq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsllvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsllvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsllvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsllvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsllvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsllvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpsllw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpsllw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpsrad<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpsrad<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpsraq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpsraq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsravd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsravd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsravq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsravq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsravw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsravw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpsraw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpsraw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpsrld<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpsrld<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpsrldq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpsrlq<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsrlvd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsrlvd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsrlvq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsrlvq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsrlvw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsrlvw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVpsrlw<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVpsubb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsubb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsubd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsubd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsubq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsubq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsubsb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsubsb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsubsw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsubsw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsubusb<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsubusb<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsubusw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsubusw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpsubw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpsubw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpternlogd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpternlogq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpternlogq( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpunpckhbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpunpckhbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpunpckhdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpunpckhdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpunpckhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpunpckhqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpunpckhwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpunpckhwd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpunpcklbw<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpunpcklbw<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpunpckldq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpunpckldq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpunpcklqdq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpunpcklqdq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpunpcklwd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpunpcklwd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpxord<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpxord<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVpxorq<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVpxorq<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangepd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vrangepd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVrangeps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vrangeps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVrcp14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrcp14pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcp14pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVrcp14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrcp14ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcp14ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVrcp28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrcp28pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcp28pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVrcp28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrcp28ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcp28ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVrcpph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrcpph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrcpph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVreducepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVreducepd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVreducepd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVreduceph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVreduceph<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVreduceph<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVreduceps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVreduceps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVreduceps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVrndscalepd<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVrndscaleph<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

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

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

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

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

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

impl CodeAsmVrndscaleps<AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

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

impl CodeAsmVrsqrt14pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrsqrt14pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrt14pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrt14ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrsqrt14ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrt14ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28pd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrsqrt28pd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrt28pd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrt28ps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrsqrt28ps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrt28ps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVrsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVrsqrtph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vrsqrtph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVscalefpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVscalefpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVscalefph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVscalefph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVscalefps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVscalefps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVscatterdpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVscatterdps<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVscatterqpd<AsmMemoryOperand, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshuff32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshuff32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshuff64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshuff64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufi32x4<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshufi32x4( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufi64x2<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshufi64x2( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshufpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVshufps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vshufps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVsqrtpd<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVsqrtpd<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsqrtpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVsqrtph<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVsqrtph<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsqrtph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterZmm, op1: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsqrtps<AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsqrtps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsubpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsubpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsubph<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsubph( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVsubps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vsubps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVunpckhpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vunpckhpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVunpckhps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vunpckhps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVunpcklpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vunpcklpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVunpcklps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vunpcklps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVxorpd<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vxorpd( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterZmm, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVxorps<AsmRegisterZmm, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vxorps( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl Debug for AsmRegisterZmm

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl From<AsmRegisterZmm> for Register

fn from(reg: AsmRegisterZmm) -> Self

Converts to this type from the input type.

impl Mul<AsmRegisterZmm> for i16

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<AsmRegisterZmm> for i32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<AsmRegisterZmm> for i64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<AsmRegisterZmm> for i8

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<AsmRegisterZmm> for isize

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<AsmRegisterZmm> for u16

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<AsmRegisterZmm> for u32

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<AsmRegisterZmm> for u64

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<AsmRegisterZmm> for u8

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<AsmRegisterZmm> for usize

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: AsmRegisterZmm) -> Self::Output

Performs the * operation. Read more

impl Mul<i16> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation. Read more

impl Mul<i32> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation. Read more

impl Mul<i64> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation. Read more

impl Mul<i8> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation. Read more

impl Mul<isize> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation. Read more

impl Mul<u16> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation. Read more

impl Mul<u32> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation. Read more

impl Mul<u64> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation. Read more

impl Mul<u8> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation. Read more

impl Mul<usize> for AsmRegisterZmm

type Output = AsmMemoryOperand

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation. Read more

impl PartialEq for AsmRegisterZmm

fn eq(&self, other: &AsmRegisterZmm) -> bool

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for AsmRegisterZmm

impl Eq for AsmRegisterZmm

impl StructuralEq for AsmRegisterZmm

impl StructuralPartialEq for AsmRegisterZmm

Auto Trait Implementations§

impl RefUnwindSafe for AsmRegisterZmm

impl Send for AsmRegisterZmm

impl Sync for AsmRegisterZmm

impl Unpin for AsmRegisterZmm

impl UnwindSafe for AsmRegisterZmm

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.