Struct iced_x86::code_asm::AsmRegisterK

pub struct AsmRegisterK { /* private fields */ }

All opmask registers.

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::k::*;

Implementations

impl AsmRegisterK

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 Clone for AsmRegisterK

fn clone(&self) -> AsmRegisterK

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CodeAsmKaddb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKaddd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKaddq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKaddw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKandb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKandd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKandnb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKandnd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKandnq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKandnw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKandq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKandw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovb<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovb<AsmRegister32, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovb<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmKmovb<AsmRegisterK, AsmRegister32> for CodeAssembler

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

impl CodeAsmKmovb<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovd<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovd<AsmRegister32, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovd<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmKmovd<AsmRegisterK, AsmRegister32> for CodeAssembler

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

impl CodeAsmKmovd<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovq<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovq<AsmRegister64, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovq<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmKmovq<AsmRegisterK, AsmRegister64> for CodeAssembler

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

impl CodeAsmKmovq<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovw<AsmMemoryOperand, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovw<AsmRegister32, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKmovw<AsmRegisterK, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmKmovw<AsmRegisterK, AsmRegister32> for CodeAssembler

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

impl CodeAsmKmovw<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKnotb<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKnotd<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKnotq<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKnotw<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKorb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKord<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKorq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKortestb<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKortestd<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKortestq<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKortestw<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKorw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKshiftlb<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

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

impl CodeAsmKshiftlb<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

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

impl CodeAsmKshiftld<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

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

impl CodeAsmKshiftld<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

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

impl CodeAsmKshiftlq<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

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

impl CodeAsmKshiftlq<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

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

impl CodeAsmKshiftlw<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

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

impl CodeAsmKshiftlw<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

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

impl CodeAsmKshiftrb<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

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

impl CodeAsmKshiftrb<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

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

impl CodeAsmKshiftrd<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

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

impl CodeAsmKshiftrd<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

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

impl CodeAsmKshiftrq<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

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

impl CodeAsmKshiftrq<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

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

impl CodeAsmKshiftrw<AsmRegisterK, AsmRegisterK, i32> for CodeAssembler

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

impl CodeAsmKshiftrw<AsmRegisterK, AsmRegisterK, u32> for CodeAssembler

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

impl CodeAsmKtestb<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKtestd<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKtestq<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKtestw<AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKunpckbw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKunpckdq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKunpckwd<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKxnorb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKxnord<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKxnorq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKxnorw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKxorb<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKxord<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKxorq<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmKxorw<AsmRegisterK, AsmRegisterK, AsmRegisterK> for CodeAssembler

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

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeq_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpeqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalse_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalse_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalsepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalseph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalseps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalsesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalsesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpfalsess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpge_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpge_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgeph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgeps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgt_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpgtss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmple_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmple_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmple_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpleph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpleps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpless<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmplt_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmplt_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpltss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_oqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_oqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_ospd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_osph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_osps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_ossd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_ossh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_ossh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_osss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_osss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneq_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneq_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpneqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnge_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnge_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngeph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngeps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngt_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpngtss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnle_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnle_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnleph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnleps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnless<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnlt_uqss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpnltss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_spd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_sph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_sps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_ssd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_ssh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpord_sss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

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

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

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

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

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

impl CodeAsmVcmpordss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vcmpps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVcmpss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vcmpss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_uspd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrue_uspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrue_usph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrue_usps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_ussd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_ussh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_ussh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrue_usss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrue_usss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruepd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptruepd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrueph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrueph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptrueps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmptrueps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruesd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruesd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruesh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruesh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmptruess<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmptruess( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_spd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunord_spd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunord_sph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunord_sps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_ssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_ssh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_ssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunord_sss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunord_sss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunordpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordph<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunordph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordps<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vcmpunordps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordsd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordsh<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordsh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVcmpunordss<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vcmpunordss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterYmm, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterYmm, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspd<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

fn vfpclasspd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspdz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspdz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspdz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterYmm, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterYmm, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassph<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

fn vfpclassph( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassphx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassphy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassphz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassphz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassphz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterYmm, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterYmm, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterZmm, i32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassps<AsmRegisterK, AsmRegisterZmm, u32> for CodeAssembler

fn vfpclassps( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsx<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsx( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsy<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsy( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasspsz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasspsz<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasspsz( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasssd<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclasssd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclasssh<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclasssh( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, i32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmMemoryOperand, u32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmMemoryOperand, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmRegisterXmm, i32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: i32 ) -> Result<(), IcedError>

impl CodeAsmVfpclassss<AsmRegisterK, AsmRegisterXmm, u32> for CodeAssembler

fn vfpclassss( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: u32 ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVp2intersectd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vp2intersectd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVp2intersectq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vp2intersectq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmb2q<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmb2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmb2q<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmb2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmb2q<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmb2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmw2d<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmw2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmw2d<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmw2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpbroadcastmw2d<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpbroadcastmw2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpequw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpeqw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpeqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsed<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalsed( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalseuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalseuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpfalsew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpfalsew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpgtw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpgtw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpled<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpleuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmplew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmplew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpltw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnequw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnequw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpneqw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpneqw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnled<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnled( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnleuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnleuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnlew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnlew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmpnltw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmpnltw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrued<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrued( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptrueuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptrueuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpcmptruew<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpcmptruew( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpub<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpub( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpud<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpud( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpuq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpuw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpuw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, i32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: i32 ) -> Result<(), IcedError>

impl CodeAsmVpcmpw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm, u32> for CodeAssembler

fn vpcmpw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm, op3: u32 ) -> Result<(), IcedError>

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovb2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

fn vpmovb2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovb2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovb2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovd2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

fn vpmovd2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovd2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovd2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovm2b<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2b( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2b<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpmovm2b( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2b<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2b( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2d<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2d( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2d<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpmovm2d( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2d<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2d( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2q<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2q( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2q<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpmovm2q( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2q<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2q( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2w<AsmRegisterXmm, AsmRegisterK> for CodeAssembler

fn vpmovm2w( &mut self, op0: AsmRegisterXmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2w<AsmRegisterYmm, AsmRegisterK> for CodeAssembler

fn vpmovm2w( &mut self, op0: AsmRegisterYmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovm2w<AsmRegisterZmm, AsmRegisterK> for CodeAssembler

fn vpmovm2w( &mut self, op0: AsmRegisterZmm, op1: AsmRegisterK ) -> Result<(), IcedError>

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovq2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

fn vpmovq2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovq2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovq2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterXmm> for CodeAssembler

fn vpmovw2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterYmm> for CodeAssembler

fn vpmovw2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpmovw2m<AsmRegisterK, AsmRegisterZmm> for CodeAssembler

fn vpmovw2m( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVpshufbitqmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vpshufbitqmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestmw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmb<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmb( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmd<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmd( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmq<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmq( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterXmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterXmm, AsmRegisterXmm> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterXmm, op2: AsmRegisterXmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterYmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterYmm, AsmRegisterYmm> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterYmm, op2: AsmRegisterYmm ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmMemoryOperand> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmMemoryOperand ) -> Result<(), IcedError>

impl CodeAsmVptestnmw<AsmRegisterK, AsmRegisterZmm, AsmRegisterZmm> for CodeAssembler

fn vptestnmw( &mut self, op0: AsmRegisterK, op1: AsmRegisterZmm, op2: AsmRegisterZmm ) -> Result<(), IcedError>

impl Debug for AsmRegisterK

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<AsmRegisterK> for Register

fn from(reg: AsmRegisterK) -> Self

Converts to this type from the input type.

impl PartialEq for AsmRegisterK

fn eq(&self, other: &AsmRegisterK) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for AsmRegisterK

impl Eq for AsmRegisterK

impl StructuralEq for AsmRegisterK

impl StructuralPartialEq for AsmRegisterK